Vulkan ® 1.2.133 - A Specification (with all published extensions)

VK_SUCCESS

To create an instance object, call:

VkResult vkCreateInstance(
    const VkInstanceCreateInfo*                 pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkInstance*                                 pInstance);

pCreateInfo is a pointer to a VkInstanceCreateInfo structure controlling creation of the instance.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pInstance points a VkInstance handle in which the resulting instance is returned.

vkCreateInstance verifies that the requested layers exist. If not, vkCreateInstance will return VK_ERROR_LAYER_NOT_PRESENT. Next vkCreateInstance verifies that the requested extensions are supported (e.g. in the implementation or in any enabled instance layer) and if any requested extension is not supported, vkCreateInstance must return VK_ERROR_EXTENSION_NOT_PRESENT. After verifying and enabling the instance layers and extensions the VkInstance object is created and returned to the application. If a requested extension is only supported by a layer, both the layer and the extension need to be specified at vkCreateInstance time for the creation to succeed.

Valid Usage

VUID-vkCreateInstance-ppEnabledExtensionNames-01388
All required extensions for each extension in the VkInstanceCreateInfo::ppEnabledExtensionNames list must also be present in that list.

Valid Usage (Implicit)

VUID-vkCreateInstance-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkInstanceCreateInfo structure
VUID-vkCreateInstance-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateInstance-pInstance-parameter
pInstance must be a valid pointer to a VkInstance handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INITIALIZATION_FAILED
VK_ERROR_LAYER_NOT_PRESENT
VK_ERROR_EXTENSION_NOT_PRESENT
VK_ERROR_INCOMPATIBLE_DRIVER

The VkInstanceCreateInfo structure is defined as:

typedef struct VkInstanceCreateInfo {
    VkStructureType             sType;
    const void*                 pNext;
    VkInstanceCreateFlags       flags;
    const VkApplicationInfo*    pApplicationInfo;
    uint32_t                    enabledLayerCount;
    const char* const*          ppEnabledLayerNames;
    uint32_t                    enabledExtensionCount;
    const char* const*          ppEnabledExtensionNames;
} VkInstanceCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
pApplicationInfo is NULL or a pointer to a VkApplicationInfo structure. If not NULL, this information helps implementations recognize behavior inherent to classes of applications. VkApplicationInfo is defined in detail below.
enabledLayerCount is the number of global layers to enable.
ppEnabledLayerNames is a pointer to an array of enabledLayerCount null-terminated UTF-8 strings containing the names of layers to enable for the created instance. See the Layers section for further details.
enabledExtensionCount is the number of global extensions to enable.
ppEnabledExtensionNames is a pointer to an array of enabledExtensionCount null-terminated UTF-8 strings containing the names of extensions to enable.

Valid Usage (Implicit)

VUID-VkInstanceCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
VUID-VkInstanceCreateInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDebugReportCallbackCreateInfoEXT, VkDebugUtilsMessengerCreateInfoEXT, VkValidationFeaturesEXT, or VkValidationFlagsEXT
VUID-VkInstanceCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkInstanceCreateInfo-flags-zerobitmask
flags must be 0
VUID-VkInstanceCreateInfo-pApplicationInfo-parameter
If pApplicationInfo is not NULL, pApplicationInfo must be a valid pointer to a valid VkApplicationInfo structure
VUID-VkInstanceCreateInfo-ppEnabledLayerNames-parameter
If enabledLayerCount is not 0, ppEnabledLayerNames must be a valid pointer to an array of enabledLayerCount null-terminated UTF-8 strings
VUID-VkInstanceCreateInfo-ppEnabledExtensionNames-parameter
If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a valid pointer to an array of enabledExtensionCount null-terminated UTF-8 strings

typedef VkFlags VkInstanceCreateFlags;

VkInstanceCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

When creating a Vulkan instance for which you wish to disable validation checks, add a VkValidationFlagsEXT structure to the pNext chain of the VkInstanceCreateInfo structure, specifying the checks to be disabled.

typedef struct VkValidationFlagsEXT {
    VkStructureType                sType;
    const void*                    pNext;
    uint32_t                       disabledValidationCheckCount;
    const VkValidationCheckEXT*    pDisabledValidationChecks;
} VkValidationFlagsEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
disabledValidationCheckCount is the number of checks to disable.
pDisabledValidationChecks is a pointer to an array of VkValidationCheckEXT values specifying the validation checks to be disabled.

Valid Usage (Implicit)

VUID-VkValidationFlagsEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT
VUID-VkValidationFlagsEXT-pDisabledValidationChecks-parameter
pDisabledValidationChecks must be a valid pointer to an array of disabledValidationCheckCount valid VkValidationCheckEXT values
VUID-VkValidationFlagsEXT-disabledValidationCheckCount-arraylength
disabledValidationCheckCount must be greater than 0

Possible values of elements of the VkValidationFlagsEXT::pDisabledValidationChecks array, specifying validation checks to be disabled, are:

typedef enum VkValidationCheckEXT {
    VK_VALIDATION_CHECK_ALL_EXT = 0,
    VK_VALIDATION_CHECK_SHADERS_EXT = 1,
    VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF
} VkValidationCheckEXT;

VK_VALIDATION_CHECK_ALL_EXT specifies that all validation checks are disabled.
VK_VALIDATION_CHECK_SHADERS_EXT specifies that shader validation is disabled.

When creating a Vulkan instance for which you wish to enable or disable specific validation features, add a VkValidationFeaturesEXT structure to the pNext chain of the VkInstanceCreateInfo structure, specifying the features to be enabled or disabled.

typedef struct VkValidationFeaturesEXT {
    VkStructureType                         sType;
    const void*                             pNext;
    uint32_t                                enabledValidationFeatureCount;
    const VkValidationFeatureEnableEXT*     pEnabledValidationFeatures;
    uint32_t                                disabledValidationFeatureCount;
    const VkValidationFeatureDisableEXT*    pDisabledValidationFeatures;
} VkValidationFeaturesEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
enabledValidationFeatureCount is the number of features to enable.
pEnabledValidationFeatures is a pointer to an array of VkValidationFeatureEnableEXT values specifying the validation features to be enabled.
disabledValidationFeatureCount is the number of features to disable.
pDisabledValidationFeatures is a pointer to an array of VkValidationFeatureDisableEXT values specifying the validation features to be disabled.

Valid Usage (Implicit)

VUID-VkValidationFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT
VUID-VkValidationFeaturesEXT-pEnabledValidationFeatures-parameter
If enabledValidationFeatureCount is not 0, pEnabledValidationFeatures must be a valid pointer to an array of enabledValidationFeatureCount valid VkValidationFeatureEnableEXT values
VUID-VkValidationFeaturesEXT-pDisabledValidationFeatures-parameter
If disabledValidationFeatureCount is not 0, pDisabledValidationFeatures must be a valid pointer to an array of disabledValidationFeatureCount valid VkValidationFeatureDisableEXT values

Possible values of elements of the VkValidationFeaturesEXT::pEnabledValidationFeatures array, specifying validation features to be enabled, are:

typedef enum VkValidationFeatureEnableEXT {
    VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0,
    VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1,
    VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2,
    VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF
} VkValidationFeatureEnableEXT;

VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT specifies that GPU-assisted validation is enabled. Activating this feature instruments shader programs to generate additional diagnostic data. This feature is disabled by default.
VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT specifies that the validation layers reserve a descriptor set binding slot for their own use. The layer reports a value for VkPhysicalDeviceLimits::maxBoundDescriptorSets that is one less than the value reported by the device. If the device supports the binding of only one descriptor set, the validation layer does not perform GPU-assisted validation. This feature is disabled by default. The GPU-assisted validation feature must be enabled in order to use this feature.
VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT specifies that Vulkan best-practices validation is enabled. Activating this feature enables the output of warnings related to common misuse of the API, but which are not explicitly prohibited by the specification. This feature is disabled by default.

Possible values of elements of the VkValidationFeaturesEXT::pDisabledValidationFeatures array, specifying validation features to be disabled, are:

typedef enum VkValidationFeatureDisableEXT {
    VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0,
    VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1,
    VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2,
    VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3,
    VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4,
    VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5,
    VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6,
    VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF
} VkValidationFeatureDisableEXT;

VK_VALIDATION_FEATURE_DISABLE_ALL_EXT specifies that all validation checks are disabled.
VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT specifies that shader validation is disabled. This feature is enabled by default.
VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT specifies that thread safety validation is disabled. This feature is enabled by default.
VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT specifies that stateless parameter validation is disabled. This feature is enabled by default.
VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT specifies that object lifetime validation is disabled. This feature is enabled by default.
VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT specifies that core validation checks are disabled. This feature is enabled by default. If this feature is disabled, the shader validation and GPU-assisted validation features are also disabled.
VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT specifies that protection against duplicate non-dispatchable object handles is disabled. This feature is enabled by default.

Note

Disabling checks such as parameter validation and object lifetime validation prevents the reporting of error conditions that can cause other validation checks to behave incorrectly or crash. Some validation checks assume that their inputs are already valid and do not always revalidate them.

Note

The VK_EXT_validation_features extension subsumes all the functionality provided in the [VK_EXT_validation_flags] extension.

The VkApplicationInfo structure is defined as:

typedef struct VkApplicationInfo {
    VkStructureType    sType;
    const void*        pNext;
    const char*        pApplicationName;
    uint32_t           applicationVersion;
    const char*        pEngineName;
    uint32_t           engineVersion;
    uint32_t           apiVersion;
} VkApplicationInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
pApplicationName is NULL or is a pointer to a null-terminated UTF-8 string containing the name of the application.
applicationVersion is an unsigned integer variable containing the developer-supplied version number of the application.
pEngineName is NULL or is a pointer to a null-terminated UTF-8 string containing the name of the engine (if any) used to create the application.
engineVersion is an unsigned integer variable containing the developer-supplied version number of the engine used to create the application.
apiVersion must be the highest version of Vulkan that the application is designed to use, encoded as described in Version Numbers. The patch version number specified in apiVersion is ignored when creating an instance object. Only the major and minor versions of the instance must match those requested in apiVersion.

Vulkan 1.0 implementations were required to return VK_ERROR_INCOMPATIBLE_DRIVER if apiVersion was larger than 1.0. Implementations that support Vulkan 1.1 or later must not return VK_ERROR_INCOMPATIBLE_DRIVER for any value of apiVersion.

Note

Because Vulkan 1.0 implementations may fail with VK_ERROR_INCOMPATIBLE_DRIVER, applications should determine the version of Vulkan available before calling vkCreateInstance. If the vkGetInstanceProcAddr returns NULL for vkEnumerateInstanceVersion, it is a Vulkan 1.0 implementation. Otherwise, the application can call vkEnumerateInstanceVersion to determine the version of Vulkan.

As long as the instance supports at least Vulkan 1.1, an application can use different versions of Vulkan with an instance than it does with a device or physical device.

Note

The Khronos validation layers will treat apiVersion as the highest API version the application targets, and will validate API usage against the minimum of that version and the implementation version (instance or device, depending on context). If an application tries to use functionality from a greater version than this, a validation error will be triggered.

For example, if the instance supports Vulkan 1.1 and three physical devices support Vulkan 1.0, Vulkan 1.1, and Vulkan 1.2, respectively, and if the application sets apiVersion to 1.2, the application can use the following versions of Vulkan:

Vulkan 1.0 can be used with the instance and with all physical devices.
Vulkan 1.1 can be used with the instance and with the physical devices that support Vulkan 1.1 and Vulkan 1.2.
Vulkan 1.2 can be used with the physical device that supports Vulkan 1.2.

If we modify the above example so that the application sets apiVersion to 1.1, then the application must not use Vulkan 1.2 functionality on the physical device that supports Vulkan 1.2.

Implicit layers must be disabled if they do not support a version at least as high as apiVersion. See the Vulkan Loader Specification and Architecture Overview document for additional information.

Note

Providing a NULL VkInstanceCreateInfo::pApplicationInfo or providing an apiVersion of 0 is equivalent to providing an apiVersion of VK_MAKE_VERSION(1,0,0).

Valid Usage (Implicit)

VUID-VkApplicationInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_APPLICATION_INFO
VUID-VkApplicationInfo-pNext-pNext
pNext must be NULL
VUID-VkApplicationInfo-pApplicationName-parameter
If pApplicationName is not NULL, pApplicationName must be a null-terminated UTF-8 string
VUID-VkApplicationInfo-pEngineName-parameter
If pEngineName is not NULL, pEngineName must be a null-terminated UTF-8 string

To destroy an instance, call:

void vkDestroyInstance(
    VkInstance                                  instance,
    const VkAllocationCallbacks*                pAllocator);

instance is the handle of the instance to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyInstance-instance-00629
All child objects created using instance must have been destroyed prior to destroying instance
VUID-vkDestroyInstance-instance-00630
If VkAllocationCallbacks were provided when instance was created, a compatible set of callbacks must be provided here
VUID-vkDestroyInstance-instance-00631
If no VkAllocationCallbacks were provided when instance was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyInstance-instance-parameter
If instance is not NULL, instance must be a valid VkInstance handle
VUID-vkDestroyInstance-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure

Host Synchronization

Host access to instance must be externally synchronized

4. Devices and Queues

Once Vulkan is initialized, devices and queues are the primary objects used to interact with a Vulkan implementation.

Vulkan separates the concept of physical and logical devices. A physical device usually represents a single complete implementation of Vulkan (excluding instance-level functionality) available to the host, of which there are a finite number. A logical device represents an instance of that implementation with its own state and resources independent of other logical devices.

Physical devices are represented by VkPhysicalDevice handles:

VK_DEFINE_HANDLE(VkPhysicalDevice)

4.1. Physical Devices

To retrieve a list of physical device objects representing the physical devices installed in the system, call:

VkResult vkEnumeratePhysicalDevices(
    VkInstance                                  instance,
    uint32_t*                                   pPhysicalDeviceCount,
    VkPhysicalDevice*                           pPhysicalDevices);

instance is a handle to a Vulkan instance previously created with vkCreateInstance.
pPhysicalDeviceCount is a pointer to an integer related to the number of physical devices available or queried, as described below.
pPhysicalDevices is either NULL or a pointer to an array of VkPhysicalDevice handles.

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 handles 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, VK_INCOMPLETE will be returned instead of VK_SUCCESS, to indicate that not all the available physical devices were returned.

Valid Usage (Implicit)

VUID-vkEnumeratePhysicalDevices-instance-parameter
instance must be a valid VkInstance handle
VUID-vkEnumeratePhysicalDevices-pPhysicalDeviceCount-parameter
pPhysicalDeviceCount must be a valid pointer to a uint32_t value
VUID-vkEnumeratePhysicalDevices-pPhysicalDevices-parameter
If the value referenced by pPhysicalDeviceCount is not 0, and pPhysicalDevices is not NULL, pPhysicalDevices must be a valid pointer to an array of pPhysicalDeviceCount VkPhysicalDevice handles

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INITIALIZATION_FAILED

To query general properties of physical devices once enumerated, call:

void vkGetPhysicalDeviceProperties(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceProperties*                 pProperties);

physicalDevice is the handle to the physical device whose properties will be queried.
pProperties is a pointer to a VkPhysicalDeviceProperties structure in which properties are returned.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceProperties-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceProperties-pProperties-parameter
pProperties must be a valid pointer to a VkPhysicalDeviceProperties structure

The VkPhysicalDeviceProperties structure is defined as:

typedef struct VkPhysicalDeviceProperties {
    uint32_t                            apiVersion;
    uint32_t                            driverVersion;
    uint32_t                            vendorID;
    uint32_t                            deviceID;
    VkPhysicalDeviceType                deviceType;
    char                                deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
    uint8_t                             pipelineCacheUUID[VK_UUID_SIZE];
    VkPhysicalDeviceLimits              limits;
    VkPhysicalDeviceSparseProperties    sparseProperties;
} VkPhysicalDeviceProperties;

apiVersion is the version of Vulkan supported by the device, encoded as described in Version Numbers.
driverVersion is the vendor-specified version of the driver.
vendorID is a unique identifier for the vendor (see below) of the physical device.
deviceID is a unique identifier for the physical device among devices available from the vendor.
deviceType is a VkPhysicalDeviceType specifying the type of device.
deviceName is an array of VK_MAX_PHYSICAL_DEVICE_NAME_SIZE char containing a null-terminated UTF-8 string which is the name of the device.
pipelineCacheUUID is an array of VK_UUID_SIZE uint8_t values representing a universally unique identifier for the device.
limits is the VkPhysicalDeviceLimits structure specifying device-specific limits of the physical device. See Limits for details.
sparseProperties is the VkPhysicalDeviceSparseProperties structure specifying various sparse related properties of the physical device. See Sparse Properties for details.

Note

The value of apiVersion may be different than the version returned by vkEnumerateInstanceVersion; either higher or lower. In such cases, the application must not use functionality that exceeds the version of Vulkan associated with a given object. The pApiVersion parameter returned by vkEnumerateInstanceVersion is the version associated with a VkInstance and its children, except for a VkPhysicalDevice and its children. VkPhysicalDeviceProperties::apiVersion is the version associated with a VkPhysicalDevice and its children.

The vendorID and deviceID fields are provided to allow applications to adapt to device characteristics that are not adequately exposed by other Vulkan queries.

Note

These may include performance profiles, hardware errata, or other characteristics.

The vendor identified by vendorID is the entity responsible for the most salient characteristics of the underlying implementation of the VkPhysicalDevice being queried.

Note

For example, in the case of a discrete GPU implementation, this should be the GPU chipset vendor. In the case of a hardware accelerator integrated into a system-on-chip (SoC), this should be the supplier of the silicon IP used to create the accelerator.

If the vendor has a PCI vendor ID, the low 16 bits of vendorID must contain that PCI vendor ID, and the remaining bits must be set to zero. Otherwise, the value returned must be a valid Khronos vendor ID, obtained as described in the Vulkan Documentation and Extensions: Procedures and Conventions document in the section “Registering a Vendor ID with Khronos”. Khronos vendor IDs are allocated starting at 0x10000, to distinguish them from the PCI vendor ID namespace. Khronos vendor IDs are symbolically defined in the VkVendorId type.

The vendor is also responsible for the value returned in deviceID. If the implementation is driven primarily by a PCI device with a PCI device ID, the low 16 bits of deviceID must contain that PCI device ID, and the remaining bits must be set to zero. Otherwise, the choice of what values to return may be dictated by operating system or platform policies - but should uniquely identify both the device version and any major configuration options (for example, core count in the case of multicore devices).

Note

The same device ID should be used for all physical implementations of that device version and configuration. For example, all uses of a specific silicon IP GPU version and configuration should use the same device ID, even if those uses occur in different SoCs.

Khronos vendor IDs which may be returned in VkPhysicalDeviceProperties::vendorID are:

typedef enum VkVendorId {
    VK_VENDOR_ID_VIV = 0x10001,
    VK_VENDOR_ID_VSI = 0x10002,
    VK_VENDOR_ID_KAZAN = 0x10003,
    VK_VENDOR_ID_CODEPLAY = 0x10004,
    VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF
} VkVendorId;

Note

Khronos vendor IDs may be allocated by vendors at any time. Only the latest canonical versions of this Specification, of the corresponding vk.xml API Registry, and of the corresponding vulkan_core.h header file must contain all reserved Khronos vendor IDs.

Only Khronos vendor IDs are given symbolic names at present. PCI vendor IDs returned by the implementation can be looked up in the PCI-SIG database.

The physical device types which may be returned in VkPhysicalDeviceProperties::deviceType are:

typedef enum VkPhysicalDeviceType {
    VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
    VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
    VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
    VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
    VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
    VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkPhysicalDeviceType;

VK_PHYSICAL_DEVICE_TYPE_OTHER - the device does not match any other available types.
VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU - the device is typically one embedded in or tightly coupled with the host.
VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU - the device is typically a separate processor connected to the host via an interlink.
VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU - the device is typically a virtual node in a virtualization environment.
VK_PHYSICAL_DEVICE_TYPE_CPU - the device is typically running on the same processors as the host.

The physical device type is advertised for informational purposes only, and does not directly affect the operation of the system. However, the device type may correlate with other advertised properties or capabilities of the system, such as how many memory heaps there are.

To query general properties of physical devices once enumerated, call:

void vkGetPhysicalDeviceProperties2(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceProperties2*                pProperties);

or the equivalent command

void vkGetPhysicalDeviceProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceProperties2*                pProperties);

physicalDevice is the handle to the physical device whose properties will be queried.
pProperties is a pointer to a VkPhysicalDeviceProperties2 structure in which properties are returned.

Each structure in pProperties and its pNext chain contain members corresponding to properties or implementation-dependent limits. vkGetPhysicalDeviceProperties2 writes each member to a value indicating the value of that property or limit.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceProperties2-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceProperties2-pProperties-parameter
pProperties must be a valid pointer to a VkPhysicalDeviceProperties2 structure

The VkPhysicalDeviceProperties2 structure is defined as:

typedef struct VkPhysicalDeviceProperties2 {
    VkStructureType               sType;
    void*                         pNext;
    VkPhysicalDeviceProperties    properties;
} VkPhysicalDeviceProperties2;

or the equivalent

typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
properties is a VkPhysicalDeviceProperties structure describing properties of the physical device. This structure is written with the same values as if it were written by vkGetPhysicalDeviceProperties.

The pNext chain of this structure is used to extend the structure with properties defined by extensions.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceProperties2-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2
VUID-VkPhysicalDeviceProperties2-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceCooperativeMatrixPropertiesNV, VkPhysicalDeviceDepthStencilResolveProperties, VkPhysicalDeviceDescriptorIndexingProperties, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDriverProperties, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceFloatControlsProperties, VkPhysicalDeviceFragmentDensityMapPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceInlineUniformBlockPropertiesEXT, VkPhysicalDeviceLineRasterizationPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePerformanceQueryPropertiesKHR, VkPhysicalDevicePointClippingProperties, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxProperties, VkPhysicalDeviceShaderCoreProperties2AMD, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV, VkPhysicalDeviceShadingRateImagePropertiesNV, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceSubgroupSizeControlPropertiesEXT, VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT, VkPhysicalDeviceTimelineSemaphoreProperties, VkPhysicalDeviceTransformFeedbackPropertiesEXT, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT, VkPhysicalDeviceVulkan11Properties, or VkPhysicalDeviceVulkan12Properties
VUID-VkPhysicalDeviceProperties2-sType-unique
The sType value of each struct in the pNext chain must be unique

To query the properties of the driver corresponding to Vulkan 1.1 functionality, add VkPhysicalDeviceVulkan11Properties to the pNext chain of the VkPhysicalDeviceProperties2 structure.

The VkPhysicalDeviceVulkan11Properties structure is defined as:

typedef struct VkPhysicalDeviceVulkan11Properties {
    VkStructureType            sType;
    void*                      pNext;
    uint8_t                    deviceUUID[VK_UUID_SIZE];
    uint8_t                    driverUUID[VK_UUID_SIZE];
    uint8_t                    deviceLUID[VK_LUID_SIZE];
    uint32_t                   deviceNodeMask;
    VkBool32                   deviceLUIDValid;
    uint32_t                   subgroupSize;
    VkShaderStageFlags         subgroupSupportedStages;
    VkSubgroupFeatureFlags     subgroupSupportedOperations;
    VkBool32                   subgroupQuadOperationsInAllStages;
    VkPointClippingBehavior    pointClippingBehavior;
    uint32_t                   maxMultiviewViewCount;
    uint32_t                   maxMultiviewInstanceIndex;
    VkBool32                   protectedNoFault;
    uint32_t                   maxPerSetDescriptors;
    VkDeviceSize               maxMemoryAllocationSize;
} VkPhysicalDeviceVulkan11Properties;

deviceUUID is an array of VK_UUID_SIZE uint8_t values representing a universally unique identifier for the device.
driverUUID is an array of VK_UUID_SIZE uint8_t values representing a universally unique identifier for the driver build in use by the device.
deviceLUID is an array of VK_LUID_SIZE uint8_t values representing a locally unique identifier for the device.
deviceNodeMask is a uint32_t bitfield identifying the node within a linked device adapter corresponding to the device.
deviceLUIDValid is a boolean value that will be VK_TRUE if deviceLUID contains a valid LUID and deviceNodeMask contains a valid node mask, and VK_FALSE if they do not.
subgroupSize is the default number of invocations in each subgroup. subgroupSize is at least 1 if any of the physical device’s queues support VK_QUEUE_GRAPHICS_BIT or VK_QUEUE_COMPUTE_BIT. subgroupSize is a power-of-two.
subgroupSupportedStages is a bitfield of VkShaderStageFlagBits describing the shader stages that subgroup operations are supported in. subgroupSupportedStages will have the VK_SHADER_STAGE_COMPUTE_BIT bit set if any of the physical device’s queues support VK_QUEUE_COMPUTE_BIT.
subgroupSupportedOperations is a bitmask of VkSubgroupFeatureFlagBits specifying the sets of subgroup operations supported on this device. subgroupSupportedOperations will have the VK_SUBGROUP_FEATURE_BASIC_BIT bit set if any of the physical device’s queues support VK_QUEUE_GRAPHICS_BIT or VK_QUEUE_COMPUTE_BIT.
subgroupQuadOperationsInAllStages is a boolean specifying whether quad subgroup operations are available in all stages, or are restricted to fragment and compute stages.
pointClippingBehavior is a VkPointClippingBehavior value specifying the point clipping behavior supported by the implementation.
maxMultiviewViewCount is one greater than the maximum view index that can be used in a subpass.
maxMultiviewInstanceIndex is the maximum valid value of instance index allowed to be generated by a drawing command recorded within a subpass of a multiview render pass instance.
protectedNoFault specifies the behavior of the implementation when protected memory access rules are broken. If protectedNoFault is VK_TRUE, breaking those rules will not result in process termination or device loss.
maxPerSetDescriptors is a maximum number of descriptors (summed over all descriptor types) in a single descriptor set that is guaranteed to satisfy any implementation-dependent constraints on the size of a descriptor set itself. Applications can query whether a descriptor set that goes beyond this limit is supported using vkGetDescriptorSetLayoutSupport.
maxMemoryAllocationSize is the maximum size of a memory allocation that can be created, even if there is more space available in the heap.

The members of VkPhysicalDeviceVulkan11Properties must have the same values as the corresponding members of VkPhysicalDeviceIDProperties, VkPhysicalDeviceSubgroupProperties, VkPhysicalDevicePointClippingProperties, VkPhysicalDeviceMultiviewProperties, VkPhysicalDeviceProtectedMemoryProperties, and VkPhysicalDeviceMaintenance3Properties.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceVulkan11Properties-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES
VUID-VkPhysicalDeviceVulkan11Properties-pointClippingBehavior-parameter
pointClippingBehavior must be a valid VkPointClippingBehavior value

To query the properties of the driver corresponding to Vulkan 1.2 functionality, add VkPhysicalDeviceVulkan12Properties to the pNext chain of the VkPhysicalDeviceProperties2 structure.

The VkPhysicalDeviceVulkan12Properties structure is defined as:

typedef struct VkPhysicalDeviceVulkan12Properties {
    VkStructureType                      sType;
    void*                                pNext;
    VkDriverId                           driverID;
    char                                 driverName[VK_MAX_DRIVER_NAME_SIZE];
    char                                 driverInfo[VK_MAX_DRIVER_INFO_SIZE];
    VkConformanceVersion                 conformanceVersion;
    VkShaderFloatControlsIndependence    denormBehaviorIndependence;
    VkShaderFloatControlsIndependence    roundingModeIndependence;
    VkBool32                             shaderSignedZeroInfNanPreserveFloat16;
    VkBool32                             shaderSignedZeroInfNanPreserveFloat32;
    VkBool32                             shaderSignedZeroInfNanPreserveFloat64;
    VkBool32                             shaderDenormPreserveFloat16;
    VkBool32                             shaderDenormPreserveFloat32;
    VkBool32                             shaderDenormPreserveFloat64;
    VkBool32                             shaderDenormFlushToZeroFloat16;
    VkBool32                             shaderDenormFlushToZeroFloat32;
    VkBool32                             shaderDenormFlushToZeroFloat64;
    VkBool32                             shaderRoundingModeRTEFloat16;
    VkBool32                             shaderRoundingModeRTEFloat32;
    VkBool32                             shaderRoundingModeRTEFloat64;
    VkBool32                             shaderRoundingModeRTZFloat16;
    VkBool32                             shaderRoundingModeRTZFloat32;
    VkBool32                             shaderRoundingModeRTZFloat64;
    uint32_t                             maxUpdateAfterBindDescriptorsInAllPools;
    VkBool32                             shaderUniformBufferArrayNonUniformIndexingNative;
    VkBool32                             shaderSampledImageArrayNonUniformIndexingNative;
    VkBool32                             shaderStorageBufferArrayNonUniformIndexingNative;
    VkBool32                             shaderStorageImageArrayNonUniformIndexingNative;
    VkBool32                             shaderInputAttachmentArrayNonUniformIndexingNative;
    VkBool32                             robustBufferAccessUpdateAfterBind;
    VkBool32                             quadDivergentImplicitLod;
    uint32_t                             maxPerStageDescriptorUpdateAfterBindSamplers;
    uint32_t                             maxPerStageDescriptorUpdateAfterBindUniformBuffers;
    uint32_t                             maxPerStageDescriptorUpdateAfterBindStorageBuffers;
    uint32_t                             maxPerStageDescriptorUpdateAfterBindSampledImages;
    uint32_t                             maxPerStageDescriptorUpdateAfterBindStorageImages;
    uint32_t                             maxPerStageDescriptorUpdateAfterBindInputAttachments;
    uint32_t                             maxPerStageUpdateAfterBindResources;
    uint32_t                             maxDescriptorSetUpdateAfterBindSamplers;
    uint32_t                             maxDescriptorSetUpdateAfterBindUniformBuffers;
    uint32_t                             maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
    uint32_t                             maxDescriptorSetUpdateAfterBindStorageBuffers;
    uint32_t                             maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
    uint32_t                             maxDescriptorSetUpdateAfterBindSampledImages;
    uint32_t                             maxDescriptorSetUpdateAfterBindStorageImages;
    uint32_t                             maxDescriptorSetUpdateAfterBindInputAttachments;
    VkResolveModeFlags                   supportedDepthResolveModes;
    VkResolveModeFlags                   supportedStencilResolveModes;
    VkBool32                             independentResolveNone;
    VkBool32                             independentResolve;
    VkBool32                             filterMinmaxSingleComponentFormats;
    VkBool32                             filterMinmaxImageComponentMapping;
    uint64_t                             maxTimelineSemaphoreValueDifference;
    VkSampleCountFlags                   framebufferIntegerColorSampleCounts;
} VkPhysicalDeviceVulkan12Properties;

driverID is a unique identifier for the driver of the physical device.
driverName is an array of VK_MAX_DRIVER_NAME_SIZE_KHR char containing a null-terminated UTF-8 string which is the name of the driver.
driverInfo is an array of VK_MAX_DRIVER_INFO_SIZE_KHR char containing a null-terminated UTF-8 string with additional information about the driver.
conformanceVersion is the version of the Vulkan conformance test this driver is conformant against (see VkConformanceVersion).
denormBehaviorIndependence is a VkShaderFloatControlsIndependence value indicating whether, and how, denorm behavior can be set independently for different bit widths.
roundingModeIndependence is a VkShaderFloatControlsIndependence value indicating whether, and how, rounding modes can be set independently for different bit widths.
shaderSignedZeroInfNanPreserveFloat16 is a boolean value indicating whether sign of a zero, Nans and \(\pm\infty\) can be preserved in 16-bit floating-point computations. It also indicates whether the SignedZeroInfNanPreserve execution mode can be used for 16-bit floating-point types.
shaderSignedZeroInfNanPreserveFloat32 is a boolean value indicating whether sign of a zero, Nans and \(\pm\infty\) can be preserved in 32-bit floating-point computations. It also indicates whether the SignedZeroInfNanPreserve execution mode can be used for 32-bit floating-point types.
shaderSignedZeroInfNanPreserveFloat64 is a boolean value indicating whether sign of a zero, Nans and \(\pm\infty\) can be preserved in 64-bit floating-point computations. It also indicates whether the SignedZeroInfNanPreserve execution mode can be used for 64-bit floating-point types.
shaderDenormPreserveFloat16 is a boolean value indicating whether denormals can be preserved in 16-bit floating-point computations. It also indicates whether the DenormPreserve execution mode can be used for 16-bit floating-point types.
shaderDenormPreserveFloat32 is a boolean value indicating whether denormals can be preserved in 32-bit floating-point computations. It also indicates whether the DenormPreserve execution mode can be used for 32-bit floating-point types.
shaderDenormPreserveFloat64 is a boolean value indicating whether denormals can be preserved in 64-bit floating-point computations. It also indicates whether the DenormPreserve execution mode can be used for 64-bit floating-point types.
shaderDenormFlushToZeroFloat16 is a boolean value indicating whether denormals can be flushed to zero in 16-bit floating-point computations. It also indicates whether the DenormFlushToZero execution mode can be used for 16-bit floating-point types.
shaderDenormFlushToZeroFloat32 is a boolean value indicating whether denormals can be flushed to zero in 32-bit floating-point computations. It also indicates whether the DenormFlushToZero execution mode can be used for 32-bit floating-point types.
shaderDenormFlushToZeroFloat64 is a boolean value indicating whether denormals can be flushed to zero in 64-bit floating-point computations. It also indicates whether the DenormFlushToZero execution mode can be used for 64-bit floating-point types.
shaderRoundingModeRTEFloat16 is a boolean value indicating whether an implementation supports the round-to-nearest-even rounding mode for 16-bit floating-point arithmetic and conversion instructions. It also indicates whether the RoundingModeRTE execution mode can be used for 16-bit floating-point types.
shaderRoundingModeRTEFloat32 is a boolean value indicating whether an implementation supports the round-to-nearest-even rounding mode for 32-bit floating-point arithmetic and conversion instructions. It also indicates whether the RoundingModeRTE execution mode can be used for 32-bit floating-point types.
shaderRoundingModeRTEFloat64 is a boolean value indicating whether an implementation supports the round-to-nearest-even rounding mode for 64-bit floating-point arithmetic and conversion instructions. It also indicates whether the RoundingModeRTE execution mode can be used for 64-bit floating-point types.
shaderRoundingModeRTZFloat16 is a boolean value indicating whether an implementation supports the round-towards-zero rounding mode for 16-bit floating-point arithmetic and conversion instructions. It also indicates whether the RoundingModeRTZ execution mode can be used for 16-bit floating-point types.
shaderRoundingModeRTZFloat32 is a boolean value indicating whether an implementation supports the round-towards-zero rounding mode for 32-bit floating-point arithmetic and conversion instructions. It also indicates whether the RoundingModeRTZ execution mode can be used for 32-bit floating-point types.
shaderRoundingModeRTZFloat64 is a boolean value indicating whether an implementation supports the round-towards-zero rounding mode for 64-bit floating-point arithmetic and conversion instructions. It also indicates whether the RoundingModeRTZ execution mode can be used for 64-bit floating-point types.
maxUpdateAfterBindDescriptorsInAllPools is the maximum number of descriptors (summed over all descriptor types) that can be created across all pools that are created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT bit set. Pool creation may fail when this limit is exceeded, or when the space this limit represents is unable to satisfy a pool creation due to fragmentation.
shaderUniformBufferArrayNonUniformIndexingNative is a boolean value indicating whether uniform buffer descriptors natively support nonuniform indexing. If this is VK_FALSE, then a single dynamic instance of an instruction that nonuniformly indexes an array of uniform buffers may execute multiple times in order to access all the descriptors.
shaderSampledImageArrayNonUniformIndexingNative is a boolean value indicating whether sampler and image descriptors natively support nonuniform indexing. If this is VK_FALSE, then a single dynamic instance of an instruction that nonuniformly indexes an array of samplers or images may execute multiple times in order to access all the descriptors.
shaderStorageBufferArrayNonUniformIndexingNative is a boolean value indicating whether storage buffer descriptors natively support nonuniform indexing. If this is VK_FALSE, then a single dynamic instance of an instruction that nonuniformly indexes an array of storage buffers may execute multiple times in order to access all the descriptors.
shaderStorageImageArrayNonUniformIndexingNative is a boolean value indicating whether storage image descriptors natively support nonuniform indexing. If this is VK_FALSE, then a single dynamic instance of an instruction that nonuniformly indexes an array of storage images may execute multiple times in order to access all the descriptors.
shaderInputAttachmentArrayNonUniformIndexingNative is a boolean value indicating whether input attachment descriptors natively support nonuniform indexing. If this is VK_FALSE, then a single dynamic instance of an instruction that nonuniformly indexes an array of input attachments may execute multiple times in order to access all the descriptors.
robustBufferAccessUpdateAfterBind is a boolean value indicating whether robustBufferAccess can be enabled in a device simultaneously with descriptorBindingUniformBufferUpdateAfterBind, descriptorBindingStorageBufferUpdateAfterBind, descriptorBindingUniformTexelBufferUpdateAfterBind, and/or descriptorBindingStorageTexelBufferUpdateAfterBind. If this is VK_FALSE, then either robustBufferAccess must be disabled or all of these update-after-bind features must be disabled.
quadDivergentImplicitLod is a boolean value indicating whether implicit level of detail calculations for image operations have well-defined results when the image and/or sampler objects used for the instruction are not uniform within a quad. See Derivative Image Operations.
maxPerStageDescriptorUpdateAfterBindSamplers is similar to maxPerStageDescriptorSamplers but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxPerStageDescriptorUpdateAfterBindUniformBuffers is similar to maxPerStageDescriptorUniformBuffers but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxPerStageDescriptorUpdateAfterBindStorageBuffers is similar to maxPerStageDescriptorStorageBuffers but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxPerStageDescriptorUpdateAfterBindSampledImages is similar to maxPerStageDescriptorSampledImages but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxPerStageDescriptorUpdateAfterBindStorageImages is similar to maxPerStageDescriptorStorageImages but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxPerStageDescriptorUpdateAfterBindInputAttachments is similar to maxPerStageDescriptorInputAttachments but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxPerStageUpdateAfterBindResources is similar to maxPerStageResources but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxDescriptorSetUpdateAfterBindSamplers is similar to maxDescriptorSetSamplers but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxDescriptorSetUpdateAfterBindUniformBuffers is similar to maxDescriptorSetUniformBuffers but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic is similar to maxDescriptorSetUniformBuffersDynamic but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxDescriptorSetUpdateAfterBindStorageBuffers is similar to maxDescriptorSetStorageBuffers but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic is similar to maxDescriptorSetStorageBuffersDynamic but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxDescriptorSetUpdateAfterBindSampledImages is similar to maxDescriptorSetSampledImages but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxDescriptorSetUpdateAfterBindStorageImages is similar to maxDescriptorSetStorageImages but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxDescriptorSetUpdateAfterBindInputAttachments is similar to maxDescriptorSetInputAttachments but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
supportedDepthResolveModes is a bitmask of VkResolveModeFlagBits indicating the set of supported depth resolve modes. VK_RESOLVE_MODE_SAMPLE_ZERO_BIT must be included in the set but implementations may support additional modes.
supportedStencilResolveModes is a bitmask of VkResolveModeFlagBits indicating the set of supported stencil resolve modes. VK_RESOLVE_MODE_SAMPLE_ZERO_BIT must be included in the set but implementations may support additional modes. VK_RESOLVE_MODE_AVERAGE_BIT must not be included in the set.
independentResolveNone is VK_TRUE if the implementation supports setting the depth and stencil resolve modes to different values when one of those modes is VK_RESOLVE_MODE_NONE. Otherwise the implementation only supports setting both modes to the same value.
independentResolve is VK_TRUE if the implementation supports all combinations of the supported depth and stencil resolve modes, including setting either depth or stencil resolve mode to VK_RESOLVE_MODE_NONE. An implementation that supports independentResolve must also support independentResolveNone.
filterMinmaxSingleComponentFormats is a boolean value indicating whether a minimum set of required formats support min/max filtering.
filterMinmaxImageComponentMapping is a boolean value indicating whether the implementation supports non-identity component mapping of the image when doing min/max filtering.
maxTimelineSemaphoreValueDifference indicates the maximum difference allowed by the implementation between the current value of a timeline semaphore and any pending signal or wait operations.
framebufferIntegerColorSampleCounts is a bitmask of VkSampleCountFlagBits indicating the color sample counts that are supported for all framebuffer color attachments with integer formats.

The members of VkPhysicalDeviceVulkan12Properties must have the same values as the corresponding members of VkPhysicalDeviceDriverProperties, VkPhysicalDeviceFloatControlsProperties, VkPhysicalDeviceDescriptorIndexingProperties, VkPhysicalDeviceDepthStencilResolveProperties, VkPhysicalDeviceSamplerFilterMinmaxProperties, and VkPhysicalDeviceTimelineSemaphoreProperties.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceVulkan12Properties-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES
VUID-VkPhysicalDeviceVulkan12Properties-driverID-parameter
driverID must be a valid VkDriverId value
VUID-VkPhysicalDeviceVulkan12Properties-driverName-parameter
driverName must be a null-terminated UTF-8 string whose length is less than or equal to VK_MAX_DRIVER_NAME_SIZE
VUID-VkPhysicalDeviceVulkan12Properties-driverInfo-parameter
driverInfo must be a null-terminated UTF-8 string whose length is less than or equal to VK_MAX_DRIVER_INFO_SIZE
VUID-VkPhysicalDeviceVulkan12Properties-denormBehaviorIndependence-parameter
denormBehaviorIndependence must be a valid VkShaderFloatControlsIndependence value
VUID-VkPhysicalDeviceVulkan12Properties-roundingModeIndependence-parameter
roundingModeIndependence must be a valid VkShaderFloatControlsIndependence value
VUID-VkPhysicalDeviceVulkan12Properties-supportedDepthResolveModes-parameter
supportedDepthResolveModes must be a valid combination of VkResolveModeFlagBits values
VUID-VkPhysicalDeviceVulkan12Properties-supportedDepthResolveModes-requiredbitmask
supportedDepthResolveModes must not be 0
VUID-VkPhysicalDeviceVulkan12Properties-supportedStencilResolveModes-parameter
supportedStencilResolveModes must be a valid combination of VkResolveModeFlagBits values
VUID-VkPhysicalDeviceVulkan12Properties-supportedStencilResolveModes-requiredbitmask
supportedStencilResolveModes must not be 0
VUID-VkPhysicalDeviceVulkan12Properties-framebufferIntegerColorSampleCounts-parameter
framebufferIntegerColorSampleCounts must be a valid combination of VkSampleCountFlagBits values

To query the UUID and LUID of a device, add a VkPhysicalDeviceIDProperties structure to the pNext chain of the VkPhysicalDeviceProperties2 structure. The VkPhysicalDeviceIDProperties structure is defined as:

typedef struct VkPhysicalDeviceIDProperties {
    VkStructureType    sType;
    void*              pNext;
    uint8_t            deviceUUID[VK_UUID_SIZE];
    uint8_t            driverUUID[VK_UUID_SIZE];
    uint8_t            deviceLUID[VK_LUID_SIZE];
    uint32_t           deviceNodeMask;
    VkBool32           deviceLUIDValid;
} VkPhysicalDeviceIDProperties;

or the equivalent

typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.

deviceUUID is an array of VK_UUID_SIZE uint8_t values representing a universally unique identifier for the device.
driverUUID is an array of VK_UUID_SIZE uint8_t values representing a universally unique identifier for the driver build in use by the device.
deviceLUID is an array of VK_LUID_SIZE uint8_t values representing a locally unique identifier for the device.
deviceNodeMask is a uint32_t bitfield identifying the node within a linked device adapter corresponding to the device.
deviceLUIDValid is a boolean value that will be VK_TRUE if deviceLUID contains a valid LUID and deviceNodeMask contains a valid node mask, and VK_FALSE if they do not.

deviceUUID must be immutable for a given device across instances, processes, driver APIs, driver versions, and system reboots.

Applications can compare the driverUUID value across instance and process boundaries, and can make similar queries in external APIs to determine whether they are capable of sharing memory objects and resources using them with the device.

deviceUUID and/or driverUUID must be used to determine whether a particular external object can be shared between driver components, where such a restriction exists as defined in the compatibility table for the particular object type:

External memory handle types compatibility
External semaphore handle types compatibility
External fence handle types compatibility

If deviceLUIDValid is VK_FALSE, the values of deviceLUID and deviceNodeMask are undefined. If deviceLUIDValid is VK_TRUE and Vulkan is running on the Windows operating system, the contents of deviceLUID can be cast to an LUID object and must be equal to the locally unique identifier of a IDXGIAdapter1 object that corresponds to physicalDevice. If deviceLUIDValid is VK_TRUE, deviceNodeMask must contain exactly one bit. If Vulkan is running on an operating system that supports the Direct3D 12 API and physicalDevice corresponds to an individual device in a linked device adapter, deviceNodeMask identifies the Direct3D 12 node corresponding to physicalDevice. Otherwise, deviceNodeMask must be 1.

Note

Although they have identical descriptions, VkPhysicalDeviceIDProperties::deviceUUID may differ from VkPhysicalDeviceProperties2::pipelineCacheUUID. The former is intended to identify and correlate devices across API and driver boundaries, while the latter is used to identify a compatible device and driver combination to use when serializing and de-serializing pipeline state.

Note

While VkPhysicalDeviceIDProperties::deviceUUID is specified to remain consistent across driver versions and system reboots, it is not intended to be usable as a serializable persistent identifier for a device. It may change when a device is physically added to, removed from, or moved to a different connector in a system while that system is powered down. Further, there is no reasonable way to verify with conformance testing that a given device retains the same UUID in a given system across all driver versions supported in that system. While implementations should make every effort to report consistent device UUIDs across driver versions, applications should avoid relying on the persistence of this value for uses other than identifying compatible devices for external object sharing purposes.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceIDProperties-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES

To query the properties of the driver corresponding to a physical device, add a VkPhysicalDeviceDriverProperties structure to the pNext chain of the VkPhysicalDeviceProperties2 structure. The VkPhysicalDeviceDriverProperties structure is defined as:

typedef struct VkPhysicalDeviceDriverProperties {
    VkStructureType         sType;
    void*                   pNext;
    VkDriverId              driverID;
    char                    driverName[VK_MAX_DRIVER_NAME_SIZE];
    char                    driverInfo[VK_MAX_DRIVER_INFO_SIZE];
    VkConformanceVersion    conformanceVersion;
} VkPhysicalDeviceDriverProperties;

or the equivalent

typedef VkPhysicalDeviceDriverProperties VkPhysicalDeviceDriverPropertiesKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension specific structure.

driverID is a unique identifier for the driver of the physical device.
driverName is an array of VK_MAX_DRIVER_NAME_SIZE_KHR char containing a null-terminated UTF-8 string which is the name of the driver.
driverInfo is an array of VK_MAX_DRIVER_INFO_SIZE_KHR char containing a null-terminated UTF-8 string with additional information about the driver.
conformanceVersion is the version of the Vulkan conformance test this driver is conformant against (see VkConformanceVersion).

driverID must be immutable for a given driver across instances, processes, driver versions, and system reboots.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceDriverProperties-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES

Khronos driver IDs which may be returned in VkPhysicalDeviceDriverProperties::driverID are:

typedef enum VkDriverId {
    VK_DRIVER_ID_AMD_PROPRIETARY = 1,
    VK_DRIVER_ID_AMD_OPEN_SOURCE = 2,
    VK_DRIVER_ID_MESA_RADV = 3,
    VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4,
    VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5,
    VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6,
    VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7,
    VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8,
    VK_DRIVER_ID_ARM_PROPRIETARY = 9,
    VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10,
    VK_DRIVER_ID_GGP_PROPRIETARY = 11,
    VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12,
    VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY,
    VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE,
    VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV,
    VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = VK_DRIVER_ID_NVIDIA_PROPRIETARY,
    VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS,
    VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA,
    VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = VK_DRIVER_ID_IMAGINATION_PROPRIETARY,
    VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = VK_DRIVER_ID_QUALCOMM_PROPRIETARY,
    VK_DRIVER_ID_ARM_PROPRIETARY_KHR = VK_DRIVER_ID_ARM_PROPRIETARY,
    VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = VK_DRIVER_ID_GOOGLE_SWIFTSHADER,
    VK_DRIVER_ID_GGP_PROPRIETARY_KHR = VK_DRIVER_ID_GGP_PROPRIETARY,
    VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR = VK_DRIVER_ID_BROADCOM_PROPRIETARY,
    VK_DRIVER_ID_MAX_ENUM = 0x7FFFFFFF
} VkDriverId;

or the equivalent

typedef VkDriverId VkDriverIdKHR;

Note

Khronos driver IDs may be allocated by vendors at any time. There may be multiple driver IDs for the same vendor, representing different drivers (for e.g. different platforms, proprietary or open source, etc.). Only the latest canonical versions of this Specification, of the corresponding vk.xml API Registry, and of the corresponding vulkan_core.h header file must contain all reserved Khronos driver IDs.

Only driver IDs registered with Khronos are given symbolic names. There may be unregistered driver IDs returned.

The conformance test suite version an implementation is compliant with is described with the VkConformanceVersion structure:

typedef struct VkConformanceVersion {
    uint8_t    major;
    uint8_t    minor;
    uint8_t    subminor;
    uint8_t    patch;
} VkConformanceVersion;

or the equivalent

typedef VkConformanceVersion VkConformanceVersionKHR;

major is the major version number of the conformance test suite.
minor is the minor version number of the conformance test suite.
subminor is the subminor version number of the conformance test suite.
patch is the patch version number of the conformance test suite.

To query the PCI bus information of a physical device, add a VkPhysicalDevicePCIBusInfoPropertiesEXT structure to the pNext chain of the VkPhysicalDeviceProperties2 structure. The VkPhysicalDevicePCIBusInfoPropertiesEXT structure is defined as:

typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           pciDomain;
    uint32_t           pciBus;
    uint32_t           pciDevice;
    uint32_t           pciFunction;
} VkPhysicalDevicePCIBusInfoPropertiesEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
pciDomain is the PCI bus domain.
pciBus is the PCI bus identifier.
pciDevice is the PCI device identifier.
pciFunction is the PCI device function identifier.

Valid Usage (Implicit)

VUID-VkPhysicalDevicePCIBusInfoPropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT

To query properties of queues available on a physical device, call:

void vkGetPhysicalDeviceQueueFamilyProperties(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pQueueFamilyPropertyCount,
    VkQueueFamilyProperties*                    pQueueFamilyProperties);

physicalDevice is the handle to the physical device whose properties will be queried.
pQueueFamilyPropertyCount is a pointer to an integer related to the number of queue families available or queried, as described below.
pQueueFamilyProperties is either NULL or a pointer to an array of VkQueueFamilyProperties structures.

If pQueueFamilyProperties is NULL, then the number of queue families available is returned in pQueueFamilyPropertyCount. Implementations must support at least one queue family. 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 pQueueFamilyPropertyCount is less than the number of queue families available, at most pQueueFamilyPropertyCount structures will be written.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceQueueFamilyProperties-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceQueueFamilyProperties-pQueueFamilyPropertyCount-parameter
pQueueFamilyPropertyCount must be a valid pointer to a uint32_t value
VUID-vkGetPhysicalDeviceQueueFamilyProperties-pQueueFamilyProperties-parameter
If the value referenced by pQueueFamilyPropertyCount is not 0, and pQueueFamilyProperties is not NULL, pQueueFamilyProperties must be a valid pointer to an array of pQueueFamilyPropertyCount VkQueueFamilyProperties structures

The VkQueueFamilyProperties structure is defined as:

typedef struct VkQueueFamilyProperties {
    VkQueueFlags    queueFlags;
    uint32_t        queueCount;
    uint32_t        timestampValidBits;
    VkExtent3D      minImageTransferGranularity;
} VkQueueFamilyProperties;

queueFlags is a bitmask of VkQueueFlagBits indicating capabilities of the queues in this queue family.
queueCount is the unsigned integer count of queues in this queue family. Each queue family must support at least one queue.
timestampValidBits is the unsigned integer count of meaningful bits in the timestamps written via vkCmdWriteTimestamp. The valid range for the count is 36..64 bits, or a value of 0, indicating no support for timestamps. Bits outside the valid range are guaranteed to be zeros.
minImageTransferGranularity is the minimum granularity supported for image transfer operations on the queues in this queue family.

The value returned in minImageTransferGranularity has a unit of compressed texel blocks for images having a block-compressed format, and a unit of texels otherwise.

Possible values of minImageTransferGranularity are:

(0,0,0) which indicates that only whole mip levels must be transferred using the image transfer operations on the corresponding queues. In this case, the following restrictions apply to all offset and extent parameters of image transfer operations:
- The x, y, and z members of a VkOffset3D parameter must always be zero.
- The width, height, and depth members of a VkExtent3D parameter must always match the width, height, and depth of the image subresource corresponding to the parameter, respectively.
(A_x, A_y, A_z) where A_x, A_y, and A_z are all integer powers of two. In this case the following restrictions apply to all image transfer operations:
- x, y, and z of a VkOffset3D parameter must be integer multiples of A_x, A_y, and A_z, respectively.
- width of a VkExtent3D parameter must be an integer multiple of A_x, or else x + width must equal the width of the image subresource corresponding to the parameter.
- height of a VkExtent3D parameter must be an integer multiple of A_y, or else y + height must equal the height of the image subresource corresponding to the parameter.
- depth of a VkExtent3D parameter must be an integer multiple of A_z, or else z + depth must equal the depth of the image subresource corresponding to the parameter.
- If the format of the image corresponding to the parameters is one of the block-compressed formats then for the purposes of the above calculations the granularity must be scaled up by the compressed texel block dimensions.

Queues supporting graphics and/or compute operations must report (1,1,1) in minImageTransferGranularity, meaning that there are no additional restrictions on the granularity of image transfer operations for these queues. Other queues supporting image transfer operations are only required to support whole mip level transfers, thus minImageTransferGranularity for queues belonging to such queue families may be (0,0,0).

The Device Memory section describes memory properties queried from the physical device.

For physical device feature queries see the Features chapter.

Bits which may be set in VkQueueFamilyProperties::queueFlags indicating capabilities of queues in a queue family are:

typedef enum VkQueueFlagBits {
    VK_QUEUE_GRAPHICS_BIT = 0x00000001,
    VK_QUEUE_COMPUTE_BIT = 0x00000002,
    VK_QUEUE_TRANSFER_BIT = 0x00000004,
    VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
    VK_QUEUE_PROTECTED_BIT = 0x00000010,
    VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkQueueFlagBits;

VK_QUEUE_GRAPHICS_BIT specifies that queues in this queue family support graphics operations.
VK_QUEUE_COMPUTE_BIT specifies that queues in this queue family support compute operations.
VK_QUEUE_TRANSFER_BIT specifies that queues in this queue family support transfer operations.
VK_QUEUE_SPARSE_BINDING_BIT specifies that queues in this queue family support sparse memory management operations (see Sparse Resources). If any of the sparse resource features are enabled, then at least one queue family must support this bit.
if VK_QUEUE_PROTECTED_BIT is set, then the queues in this queue family support the VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT bit. (see Protected Memory). If the protected memory physical device feature is supported, then at least one queue family of at least one physical device exposed by the implementation must support this bit.

If an implementation exposes any queue family that supports graphics operations, at least one queue family of at least one physical device exposed by the implementation must support both graphics and compute operations.

Furthermore, if the protected memory physical device feature is supported, then at least one queue family of at least one physical device exposed by the implementation must support graphics operations, compute operations, and protected memory operations.

Note

All commands that are allowed on a queue that supports transfer operations are also allowed on a queue that supports either graphics or compute operations. Thus, if the capabilities of a queue family include VK_QUEUE_GRAPHICS_BIT or VK_QUEUE_COMPUTE_BIT, then reporting the VK_QUEUE_TRANSFER_BIT capability separately for that queue family is optional.

For further details see Queues.

typedef VkFlags VkQueueFlags;

VkQueueFlags is a bitmask type for setting a mask of zero or more VkQueueFlagBits.

To query properties of queues available on a physical device, call:

void vkGetPhysicalDeviceQueueFamilyProperties2(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pQueueFamilyPropertyCount,
    VkQueueFamilyProperties2*                   pQueueFamilyProperties);

or the equivalent command

void vkGetPhysicalDeviceQueueFamilyProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pQueueFamilyPropertyCount,
    VkQueueFamilyProperties2*                   pQueueFamilyProperties);

physicalDevice is the handle to the physical device whose properties will be queried.
pQueueFamilyPropertyCount is a pointer to an integer related to the number of queue families available or queried, as described in vkGetPhysicalDeviceQueueFamilyProperties.
pQueueFamilyProperties is either NULL or a pointer to an array of VkQueueFamilyProperties2 structures.

vkGetPhysicalDeviceQueueFamilyProperties2 behaves similarly to vkGetPhysicalDeviceQueueFamilyProperties, with the ability to return extended information in a pNext chain of output structures.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceQueueFamilyProperties2-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceQueueFamilyProperties2-pQueueFamilyPropertyCount-parameter
pQueueFamilyPropertyCount must be a valid pointer to a uint32_t value
VUID-vkGetPhysicalDeviceQueueFamilyProperties2-pQueueFamilyProperties-parameter
If the value referenced by pQueueFamilyPropertyCount is not 0, and pQueueFamilyProperties is not NULL, pQueueFamilyProperties must be a valid pointer to an array of pQueueFamilyPropertyCount VkQueueFamilyProperties2 structures

The VkQueueFamilyProperties2 structure is defined as:

typedef struct VkQueueFamilyProperties2 {
    VkStructureType            sType;
    void*                      pNext;
    VkQueueFamilyProperties    queueFamilyProperties;
} VkQueueFamilyProperties2;

or the equivalent

typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
queueFamilyProperties is a VkQueueFamilyProperties structure which is populated with the same values as in vkGetPhysicalDeviceQueueFamilyProperties.

Valid Usage (Implicit)

VUID-VkQueueFamilyProperties2-sType-sType
sType must be VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2
VUID-VkQueueFamilyProperties2-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkQueueFamilyCheckpointPropertiesNV
VUID-VkQueueFamilyProperties2-sType-unique
The sType value of each struct in the pNext chain must be unique

Additional queue family information can be queried by setting VkQueueFamilyProperties2::pNext to point to a VkQueueFamilyCheckpointPropertiesNV structure.

The VkQueueFamilyCheckpointPropertiesNV structure is defined as:

typedef struct VkQueueFamilyCheckpointPropertiesNV {
    VkStructureType         sType;
    void*                   pNext;
    VkPipelineStageFlags    checkpointExecutionStageMask;
} VkQueueFamilyCheckpointPropertiesNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
checkpointExecutionStageMask is a mask indicating which pipeline stages the implementation can execute checkpoint markers in.

Valid Usage (Implicit)

VUID-VkQueueFamilyCheckpointPropertiesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV

To enumerate the performance query counters available on a queue family of a physical device, call:

VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t                                    queueFamilyIndex,
    uint32_t*                                   pCounterCount,
    VkPerformanceCounterKHR*                    pCounters,
    VkPerformanceCounterDescriptionKHR*         pCounterDescriptions);

physicalDevice is the handle to the physical device whose queue family performance query counter properties will be queried.
queueFamilyIndex is the index into the queue family of the physical device we want to get properties for.
pCounterCount is a pointer to an integer related to the number of counters available or queried, as described below.
pCounters is either NULL or a pointer to an array of VkPerformanceCounterKHR structures.
pCounterDescriptions is either NULL or a pointer to an array of VkPerformanceCounterDescriptionKHR structures.

If pCounters is NULL and pCounterDescriptions is NULL, then the number of counters available is returned in pCounterCount. Otherwise, pCounterCount must point to a variable set by the user to the number of elements in the pCounters, pCounterDescriptions, or both arrays and on return the variable is overwritten with the number of structures actually written out. If pCounterCount is less than the number of counters available, at most pCounterCount structures will be written and VK_INCOMPLETE will be returned instead of VK_SUCCESS.

Valid Usage (Implicit)

VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-pCounterCount-parameter
pCounterCount must be a valid pointer to a uint32_t value
VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-pCounters-parameter
If the value referenced by pCounterCount is not 0, and pCounters is not NULL, pCounters must be a valid pointer to an array of pCounterCount VkPerformanceCounterKHR structures
VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-pCounterDescriptions-parameter
If the value referenced by pCounterCount is not 0, and pCounterDescriptions is not NULL, pCounterDescriptions must be a valid pointer to an array of pCounterCount VkPerformanceCounterDescriptionKHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INITIALIZATION_FAILED

The VkPerformanceCounterKHR structure is defined as:

typedef struct VkPerformanceCounterKHR {
    VkStructureType                   sType;
    const void*                       pNext;
    VkPerformanceCounterUnitKHR       unit;
    VkPerformanceCounterScopeKHR      scope;
    VkPerformanceCounterStorageKHR    storage;
    uint8_t                           uuid[VK_UUID_SIZE];
} VkPerformanceCounterKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
unit is a VkPerformanceCounterUnitKHR specifying the unit that the counter data will record.
scope is a VkPerformanceCounterScopeKHR specifying the scope that the counter belongs to.
storage is a VkPerformanceCounterStorageKHR specifying the storage type that the counter’s data uses.
uuid is an array of size VK_UUID_SIZE, containing 8-bit values that represent a universally unique identifier for the counter of the physical device.

Valid Usage (Implicit)

VUID-VkPerformanceCounterKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR
VUID-VkPerformanceCounterKHR-pNext-pNext
pNext must be NULL

Performance counters have an associated unit. This unit describes how to interpret the performance counter result.

The performance counter unit types which may be returned in VkPerformanceCounterKHR::unit are:

typedef enum VkPerformanceCounterUnitKHR {
    VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0,
    VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1,
    VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2,
    VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3,
    VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4,
    VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5,
    VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6,
    VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7,
    VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8,
    VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9,
    VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10,
    VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF
} VkPerformanceCounterUnitKHR;

VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR - the performance counter unit is a generic data point.
VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR - the performance counter unit is a percentage (%).
VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR - the performance counter unit is a value of nanoseconds (ns).
VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR - the performance counter unit is a value of bytes.
VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR - the performance counter unit is a value of bytes/s.
VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR - the performance counter unit is a temperature reported in Kelvin.
VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR - the performance counter unit is a value of watts (W).
VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR - the performance counter unit is a value of volts (V).
VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR - the performance counter unit is a value of amps (A).
VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR - the performance counter unit is a value of hertz (Hz).
VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR - the performance counter unit is a value of cycles.

Performance counters have an associated scope. This scope describes the granularity of a performance counter.

The performance counter scope types which may be returned in VkPerformanceCounterKHR::scope are:

typedef enum VkPerformanceCounterScopeKHR {
    VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0,
    VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1,
    VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2,
    VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR,
    VK_QUERY_SCOPE_RENDER_PASS_KHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR,
    VK_QUERY_SCOPE_COMMAND_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR,
    VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF
} VkPerformanceCounterScopeKHR;

VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR - the performance counter scope is a single complete command buffer.
VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR - the performance counter scope is zero or more complete render passes. The performance query containing the performance counter must begin and end outside a render pass instance.
VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR - the performance counter scope is zero or more commands.

Performance counters have an associated storage. This storage describes the payload of a counter result.

The performance counter storage types which may be returned in VkPerformanceCounterKHR::storage are:

typedef enum VkPerformanceCounterStorageKHR {
    VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0,
    VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1,
    VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2,
    VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3,
    VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4,
    VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5,
    VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF
} VkPerformanceCounterStorageKHR;

VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR - the performance counter storage is a 32-bit signed integer.
VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR - the performance counter storage is a 64-bit signed integer.
VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR - the performance counter storage is a 32-bit unsigned integer.
VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR - the performance counter storage is a 64-bit unsigned integer.
VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR - the performance counter storage is a 32-bit floating-point.
VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR - the performance counter storage is a 64-bit floating-point.

The VkPerformanceCounterDescriptionKHR structure is defined as:

typedef struct VkPerformanceCounterDescriptionKHR {
    VkStructureType                            sType;
    const void*                                pNext;
    VkPerformanceCounterDescriptionFlagsKHR    flags;
    char                                       name[VK_MAX_DESCRIPTION_SIZE];
    char                                       category[VK_MAX_DESCRIPTION_SIZE];
    char                                       description[VK_MAX_DESCRIPTION_SIZE];
} VkPerformanceCounterDescriptionKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkPerformanceCounterDescriptionFlagBitsKHR indicating the usage behavior for the counter.
name is an array of size VK_MAX_DESCRIPTION_SIZE, containing a null-terminated UTF-8 string specifying the name of the counter.
category is an array of size VK_MAX_DESCRIPTION_SIZE, containing a null-terminated UTF-8 string specifying the category of the counter.
description is an array of size VK_MAX_DESCRIPTION_SIZE, containing a null-terminated UTF-8 string specifying the description of the counter.

Valid Usage (Implicit)

VUID-VkPerformanceCounterDescriptionKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR
VUID-VkPerformanceCounterDescriptionKHR-pNext-pNext
pNext must be NULL

Bits which can be set in VkPerformanceCounterDescriptionKHR::flags to specify usage behavior for a command pool are:

typedef enum VkPerformanceCounterDescriptionFlagBitsKHR {
    VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = 0x00000001,
    VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = 0x00000002,
    VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkPerformanceCounterDescriptionFlagBitsKHR;

VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR specifies that recording the counter may have a noticable performance impact.
VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR specifies that concurrently recording the counter while other submitted command buffers are running may impact the accuracy of the recording.

typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR;

VkPerformanceCounterDescriptionFlagsKHR is a bitmask type for setting a mask of zero or more VkPerformanceCounterDescriptionFlagBitsKHR.

4.2. Devices

Device objects represent logical connections to physical devices. Each device exposes a number of queue families each having one or more queues. All queues in a queue family support the same operations.

As described in Physical Devices, a Vulkan application will first query for all physical devices in a system. Each physical device can then be queried for its capabilities, including its queue and queue family properties. Once an acceptable physical device is identified, an application will create a corresponding logical device. An application must create a separate logical device for each physical device it will use. The created logical device is then the primary interface to the physical device.

How to enumerate the physical devices in a system and query those physical devices for their queue family properties is described in the Physical Device Enumeration section above.

A single logical device can also be created from multiple physical devices, if those physical devices belong to the same device group. A device group is a set of physical devices that support accessing each other’s memory and recording a single command buffer that can be executed on all the physical devices. Device groups are enumerated by calling vkEnumeratePhysicalDeviceGroups, and a logical device is created from a subset of the physical devices in a device group by passing the physical devices through VkDeviceGroupDeviceCreateInfo. For two physical devices to be in the same device group, they must support identical extensions, features, and properties.

Note

Physical devices in the same device group must be so similar because there are no rules for how different features/properties would interact. They must return the same values for nearly every invariant vkGetPhysicalDevice* feature, property, capability, etc., but could potentially differ for certain queries based on things like having a different display connected, or different compositor, etc.. The specification does not attempt to enumerate which state is in each category, because such a list would quickly become out of date.

To retrieve a list of the device groups present in the system, call:

VkResult vkEnumeratePhysicalDeviceGroups(
    VkInstance                                  instance,
    uint32_t*                                   pPhysicalDeviceGroupCount,
    VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);

or the equivalent command

VkResult vkEnumeratePhysicalDeviceGroupsKHR(
    VkInstance                                  instance,
    uint32_t*                                   pPhysicalDeviceGroupCount,
    VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);

instance is a handle to a Vulkan instance previously created with vkCreateInstance.
pPhysicalDeviceGroupCount is a pointer to an integer related to the number of device groups available or queried, as described below.
pPhysicalDeviceGroupProperties is either NULL or a pointer to an array of VkPhysicalDeviceGroupProperties structures.

If pPhysicalDeviceGroupProperties is NULL, then the number of device groups available is returned in pPhysicalDeviceGroupCount. Otherwise, pPhysicalDeviceGroupCount must point to a variable set by the user to the number of elements in the pPhysicalDeviceGroupProperties array, and on return the variable is overwritten with the number of structures actually written to pPhysicalDeviceGroupProperties. If pPhysicalDeviceGroupCount is less than the number of device groups available, at most pPhysicalDeviceGroupCount structures will be written. If pPhysicalDeviceGroupCount is smaller than the number of device groups available, VK_INCOMPLETE will be returned instead of VK_SUCCESS, to indicate that not all the available device groups were returned.

Every physical device must be in exactly one device group.

Valid Usage (Implicit)

VUID-vkEnumeratePhysicalDeviceGroups-instance-parameter
instance must be a valid VkInstance handle
VUID-vkEnumeratePhysicalDeviceGroups-pPhysicalDeviceGroupCount-parameter
pPhysicalDeviceGroupCount must be a valid pointer to a uint32_t value
VUID-vkEnumeratePhysicalDeviceGroups-pPhysicalDeviceGroupProperties-parameter
If the value referenced by pPhysicalDeviceGroupCount is not 0, and pPhysicalDeviceGroupProperties is not NULL, pPhysicalDeviceGroupProperties must be a valid pointer to an array of pPhysicalDeviceGroupCount VkPhysicalDeviceGroupProperties structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INITIALIZATION_FAILED

The VkPhysicalDeviceGroupProperties structure is defined as:

typedef struct VkPhysicalDeviceGroupProperties {
    VkStructureType     sType;
    void*               pNext;
    uint32_t            physicalDeviceCount;
    VkPhysicalDevice    physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
    VkBool32            subsetAllocation;
} VkPhysicalDeviceGroupProperties;

or the equivalent

typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
physicalDeviceCount is the number of physical devices in the group.
physicalDevices is an array of VK_MAX_DEVICE_GROUP_SIZE VkPhysicalDevice handles representing all physical devices in the group. The first physicalDeviceCount elements of the array will be valid.
subsetAllocation specifies whether logical devices created from the group support allocating device memory on a subset of devices, via the deviceMask member of the VkMemoryAllocateFlagsInfo. If this is VK_FALSE, then all device memory allocations are made across all physical devices in the group. If physicalDeviceCount is 1, then subsetAllocation must be VK_FALSE.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceGroupProperties-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES
VUID-VkPhysicalDeviceGroupProperties-pNext-pNext
pNext must be NULL

4.2.1. Device Creation

Logical devices are represented by VkDevice handles:

VK_DEFINE_HANDLE(VkDevice)

A logical device is created as a connection to a physical device. To create a logical device, call:

VkResult vkCreateDevice(
    VkPhysicalDevice                            physicalDevice,
    const VkDeviceCreateInfo*                   pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkDevice*                                   pDevice);

physicalDevice must be one of the device handles returned from a call to vkEnumeratePhysicalDevices (see Physical Device Enumeration).
pCreateInfo is a pointer to a VkDeviceCreateInfo structure containing information about how to create the device.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pDevice is a pointer to a handle in which the created VkDevice is returned.

vkCreateDevice verifies that extensions and features requested in the ppEnabledExtensionNames and pEnabledFeatures members of pCreateInfo, respectively, are supported by the implementation. If any requested extension is not supported, vkCreateDevice must return VK_ERROR_EXTENSION_NOT_PRESENT. If any requested feature is not supported, vkCreateDevice must return VK_ERROR_FEATURE_NOT_PRESENT. Support for extensions can be checked before creating a device by querying vkEnumerateDeviceExtensionProperties. Support for features can similarly be checked by querying vkGetPhysicalDeviceFeatures.

After verifying and enabling the extensions the VkDevice object is created and returned to the application. If a requested extension is only supported by a layer, both the layer and the extension need to be specified at vkCreateInstance time for the creation to succeed.

Multiple logical devices can be created from the same physical device. Logical device creation may fail due to lack of device-specific resources (in addition to the other errors). If that occurs, vkCreateDevice will return VK_ERROR_TOO_MANY_OBJECTS.

Valid Usage

VUID-vkCreateDevice-ppEnabledExtensionNames-01387
All required extensions for each extension in the VkDeviceCreateInfo::ppEnabledExtensionNames list must also be present in that list.

Valid Usage (Implicit)

VUID-vkCreateDevice-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkCreateDevice-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkDeviceCreateInfo structure
VUID-vkCreateDevice-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateDevice-pDevice-parameter
pDevice must be a valid pointer to a VkDevice handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INITIALIZATION_FAILED
VK_ERROR_EXTENSION_NOT_PRESENT
VK_ERROR_FEATURE_NOT_PRESENT
VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_DEVICE_LOST

The VkDeviceCreateInfo structure is defined as:

typedef struct VkDeviceCreateInfo {
    VkStructureType                    sType;
    const void*                        pNext;
    VkDeviceCreateFlags                flags;
    uint32_t                           queueCreateInfoCount;
    const VkDeviceQueueCreateInfo*     pQueueCreateInfos;
    uint32_t                           enabledLayerCount;
    const char* const*                 ppEnabledLayerNames;
    uint32_t                           enabledExtensionCount;
    const char* const*                 ppEnabledExtensionNames;
    const VkPhysicalDeviceFeatures*    pEnabledFeatures;
} VkDeviceCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
queueCreateInfoCount is the unsigned integer size of the pQueueCreateInfos array. Refer to the Queue Creation section below for further details.
pQueueCreateInfos is a pointer to an array of VkDeviceQueueCreateInfo structures describing the queues that are requested to be created along with the logical device. Refer to the Queue Creation section below for further details.
enabledLayerCount is deprecated and ignored.
ppEnabledLayerNames is deprecated and ignored. See Device Layer Deprecation.
enabledExtensionCount is the number of device extensions to enable.
ppEnabledExtensionNames is a pointer to an array of enabledExtensionCount null-terminated UTF-8 strings containing the names of extensions to enable for the created device. See the Extensions section for further details.
pEnabledFeatures is NULL or a pointer to a VkPhysicalDeviceFeatures structure containing boolean indicators of all the features to be enabled. Refer to the Features section for further details.

Valid Usage

VUID-VkDeviceCreateInfo-queueFamilyIndex-02802
The queueFamilyIndex member of each element of pQueueCreateInfos must be unique within pQueueCreateInfos, except that two members can share the same queueFamilyIndex if one is a protected-capable queue and one is not a protected-capable queue
VUID-VkDeviceCreateInfo-pNext-00373
If the pNext chain includes a VkPhysicalDeviceFeatures2 structure, then pEnabledFeatures must be NULL
VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-01840
ppEnabledExtensionNames must not contain [VK_AMD_negative_viewport_height]
VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-03328
ppEnabledExtensionNames must not contain both [VK_KHR_buffer_device_address] and [VK_EXT_buffer_device_address]
VUID-VkDeviceCreateInfo-pNext-02829
If the pNext chain includes a VkPhysicalDeviceVulkan11Features structure, then it must not include a VkPhysicalDevice16BitStorageFeatures, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceSamplerYcbcrConversionFeatures, or VkPhysicalDeviceShaderDrawParametersFeatures structure
VUID-VkDeviceCreateInfo-pNext-02830
If the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then it must not include a VkPhysicalDevice8BitStorageFeatures, VkPhysicalDeviceShaderAtomicInt64Features, VkPhysicalDeviceShaderFloat16Int8Features, VkPhysicalDeviceDescriptorIndexingFeatures, VkPhysicalDeviceScalarBlockLayoutFeatures, VkPhysicalDeviceImagelessFramebufferFeatures, VkPhysicalDeviceUniformBufferStandardLayoutFeatures, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, VkPhysicalDeviceHostQueryResetFeatures, VkPhysicalDeviceTimelineSemaphoreFeatures, VkPhysicalDeviceBufferDeviceAddressFeatures, or VkPhysicalDeviceVulkanMemoryModelFeatures structure
VUID-VkDeviceCreateInfo-ppEnabledExtensions-02831
If ppEnabledExtensions contains "VK_KHR_draw_indirect_count" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::drawIndirectCount must be VK_TRUE
VUID-VkDeviceCreateInfo-ppEnabledExtensions-02832
If ppEnabledExtensions contains "VK_KHR_sampler_mirror_clamp_to_edge" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::samplerMirrorClampToEdge must be VK_TRUE
VUID-VkDeviceCreateInfo-ppEnabledExtensions-02833
If ppEnabledExtensions contains "VK_EXT_descriptor_indexing" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::descriptorIndexing must be VK_TRUE
VUID-VkDeviceCreateInfo-ppEnabledExtensions-02834
If ppEnabledExtensions contains "VK_EXT_sampler_filter_minmax" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::samplerFilterMinmax must be VK_TRUE
VUID-VkDeviceCreateInfo-ppEnabledExtensions-02835
If ppEnabledExtensions contains "VK_EXT_shader_viewport_index_layer" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::shaderOutputViewportIndex and VkPhysicalDeviceVulkan12Features::shaderOutputLayer must both be VK_TRUE

Valid Usage (Implicit)

VUID-VkDeviceCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
VUID-VkDeviceCreateInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice8BitStorageFeatures, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeatures, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceCoherentMemoryFeaturesAMD, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeatures, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceHostQueryResetFeatures, VkPhysicalDeviceImagelessFramebufferFeatures, VkPhysicalDeviceIndexTypeUint8FeaturesEXT, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceLineRasterizationFeaturesEXT, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDevicePerformanceQueryFeaturesKHR, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeatures, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, VkPhysicalDeviceShaderAtomicInt64Features, VkPhysicalDeviceShaderClockFeaturesKHR, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderFloat16Int8Features, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT, VkPhysicalDeviceTimelineSemaphoreFeatures, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeatures, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, VkPhysicalDeviceVulkan11Features, VkPhysicalDeviceVulkan12Features, VkPhysicalDeviceVulkanMemoryModelFeatures, or VkPhysicalDeviceYcbcrImageArraysFeaturesEXT
VUID-VkDeviceCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkDeviceCreateInfo-flags-zerobitmask
flags must be 0
VUID-VkDeviceCreateInfo-pQueueCreateInfos-parameter
pQueueCreateInfos must be a valid pointer to an array of queueCreateInfoCount valid VkDeviceQueueCreateInfo structures
VUID-VkDeviceCreateInfo-ppEnabledLayerNames-parameter
If enabledLayerCount is not 0, ppEnabledLayerNames must be a valid pointer to an array of enabledLayerCount null-terminated UTF-8 strings
VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-parameter
If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a valid pointer to an array of enabledExtensionCount null-terminated UTF-8 strings
VUID-VkDeviceCreateInfo-pEnabledFeatures-parameter
If pEnabledFeatures is not NULL, pEnabledFeatures must be a valid pointer to a valid VkPhysicalDeviceFeatures structure
VUID-VkDeviceCreateInfo-queueCreateInfoCount-arraylength
queueCreateInfoCount must be greater than 0

typedef VkFlags VkDeviceCreateFlags;

VkDeviceCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

A logical device can be created that connects to one or more physical devices by adding a VkDeviceGroupDeviceCreateInfo structure to the pNext chain of VkDeviceCreateInfo. The VkDeviceGroupDeviceCreateInfo structure is defined as:

typedef struct VkDeviceGroupDeviceCreateInfo {
    VkStructureType            sType;
    const void*                pNext;
    uint32_t                   physicalDeviceCount;
    const VkPhysicalDevice*    pPhysicalDevices;
} VkDeviceGroupDeviceCreateInfo;

or the equivalent

typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
physicalDeviceCount is the number of elements in the pPhysicalDevices array.
pPhysicalDevices is a pointer to an array of physical device handles belonging to the same device group.

The elements of the pPhysicalDevices array are an ordered list of the physical devices that the logical device represents. These must be a subset of a single device group, and need not be in the same order as they were enumerated. The order of the physical devices in the pPhysicalDevices array determines the device index of each physical device, with element i being assigned a device index of i. Certain commands and structures refer to one or more physical devices by using device indices or device masks formed using device indices.

A logical device created without using VkDeviceGroupDeviceCreateInfo, or with physicalDeviceCount equal to zero, is equivalent to a physicalDeviceCount of one and pPhysicalDevices pointing to the physicalDevice parameter to vkCreateDevice. In particular, the device index of that physical device is zero.

Valid Usage

VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-00375
Each element of pPhysicalDevices must be unique
VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-00376
All elements of pPhysicalDevices must be in the same device group as enumerated by vkEnumeratePhysicalDeviceGroups
VUID-VkDeviceGroupDeviceCreateInfo-physicalDeviceCount-00377
If physicalDeviceCount is not 0, the physicalDevice parameter of vkCreateDevice must be an element of pPhysicalDevices.

Valid Usage (Implicit)

VUID-VkDeviceGroupDeviceCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO
VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-parameter
If physicalDeviceCount is not 0, pPhysicalDevices must be a valid pointer to an array of physicalDeviceCount valid VkPhysicalDevice handles

To specify whether device memory allocation is allowed beyond the size reported by VkPhysicalDeviceMemoryProperties, add a VkDeviceMemoryOverallocationCreateInfoAMD structure to the pNext chain of the VkDeviceCreateInfo structure. If this structure is not specified, it is as if the VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD value is used.

typedef struct VkDeviceMemoryOverallocationCreateInfoAMD {
    VkStructureType                      sType;
    const void*                          pNext;
    VkMemoryOverallocationBehaviorAMD    overallocationBehavior;
} VkDeviceMemoryOverallocationCreateInfoAMD;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
overallocationBehavior is the desired overallocation behavior.

Valid Usage (Implicit)

VUID-VkDeviceMemoryOverallocationCreateInfoAMD-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD
VUID-VkDeviceMemoryOverallocationCreateInfoAMD-overallocationBehavior-parameter
overallocationBehavior must be a valid VkMemoryOverallocationBehaviorAMD value

Possible values for VkDeviceMemoryOverallocationCreateInfoAMD::overallocationBehavior include:

typedef enum VkMemoryOverallocationBehaviorAMD {
    VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0,
    VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1,
    VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2,
    VK_MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD = 0x7FFFFFFF
} VkMemoryOverallocationBehaviorAMD;

VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD lets the implementation decide if overallocation should be allowed.
VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD specifies overallocation is allowed if platform permits.
VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD specifies the application is not allowed to allocate device memory beyond the heap sizes reported by VkPhysicalDeviceMemoryProperties. Allocations that are not explicitly made by the application within the scope of the Vulkan instance are not accounted for.

4.2.2. Device Use

The following is a high-level list of VkDevice uses along with references on where to find more information:

Creation of queues. See the Queues section below for further details.
Creation and tracking of various synchronization constructs. See Synchronization and Cache Control for further details.
Allocating, freeing, and managing memory. See Memory Allocation and Resource Creation for further details.
Creation and destruction of command buffers and command buffer pools. See Command Buffers for further details.
Creation, destruction, and management of graphics state. See Pipelines and Resource Descriptors, among others, for further details.

4.2.3. Lost Device

A logical device may become lost for a number of implementation-specific reasons, indicating that pending and future command execution may fail and cause resources and backing memory to become undefined.

Note

Typical reasons for device loss will include things like execution timing out (to prevent denial of service), power management events, platform resource management, implementation errors.

Applications not adhering to valid usage may also result in device loss being reported, however this is not guaranteed. Even if device loss is reported, the system may be in an unrecoverable state, and further usage of the API is still considered invalid.

When this happens, certain commands will return VK_ERROR_DEVICE_LOST (see Error Codes for a list of such commands). After any such event, the logical device is considered lost. It is not possible to reset the logical device to a non-lost state, however the lost state is specific to a logical device (VkDevice), and the corresponding physical device (VkPhysicalDevice) may be otherwise unaffected.

In some cases, the physical device may also be lost, and attempting to create a new logical device will fail, returning VK_ERROR_DEVICE_LOST. This is usually indicative of a problem with the underlying implementation, or its connection to the host. If the physical device has not been lost, and a new logical device is successfully created from that physical device, it must be in the non-lost state.

Note

Whilst logical device loss may be recoverable, in the case of physical device loss, it is unlikely that an application will be able to recover unless additional, unaffected physical devices exist on the system. The error is largely informational and intended only to inform the user that a platform issue has occurred, and should be investigated further. For example, underlying hardware may have developed a fault or become physically disconnected from the rest of the system. In many cases, physical device loss may cause other more serious issues such as the operating system crashing; in which case it may not be reported via the Vulkan API.

When a device is lost, its child objects are not implicitly destroyed and their handles are still valid. Those objects must still be destroyed before their parents or the device can be destroyed (see the Object Lifetime section). The host address space corresponding to device memory mapped using vkMapMemory is still valid, and host memory accesses to these mapped regions are still valid, but the contents are undefined. It is still legal to call any API command on the device and child objects.

Once a device is lost, command execution may fail, and commands that return a VkResult may return VK_ERROR_DEVICE_LOST. Commands that do not allow run-time errors must still operate correctly for valid usage and, if applicable, return valid data.

Commands that wait indefinitely for device execution (namely vkDeviceWaitIdle, vkQueueWaitIdle, vkWaitForFences or vkAcquireNextImageKHR with a maximum timeout, and vkGetQueryPoolResults with the VK_QUERY_RESULT_WAIT_BIT bit set in flags) must return in finite time even in the case of a lost device, and return either VK_SUCCESS or VK_ERROR_DEVICE_LOST. For any command that may return VK_ERROR_DEVICE_LOST, for the purpose of determining whether a command buffer is in the pending state, or whether resources are considered in-use by the device, a return value of VK_ERROR_DEVICE_LOST is equivalent to VK_SUCCESS.

The content of any external memory objects that have been exported from or imported to a lost device become undefined. Objects on other logical devices or in other APIs which are associated with the same underlying memory resource as the external memory objects on the lost device are unaffected other than their content becoming undefined. The layout of subresources of images on other logical devices that are bound to VkDeviceMemory objects associated with the same underlying memory resources as external memory objects on the lost device becomes VK_IMAGE_LAYOUT_UNDEFINED.

The state of VkSemaphore objects on other logical devices created by importing a semaphore payload with temporary permanence which was exported from the lost device is undefined. The state of VkSemaphore objects on other logical devices that permanently share a semaphore payload with a VkSemaphore object on the lost device is undefined, and remains undefined following any subsequent signal operations. Implementations must ensure pending and subsequently submitted wait operations on such semaphores behave as defined in Semaphore State Requirements For Wait Operations for external semaphores not in a valid state for a wait operation.

editing-note

TODO (piman) - I do not think we are very clear about what “in-use by the device” means.

4.2.4. Device Destruction

To destroy a device, call:

void vkDestroyDevice(
    VkDevice                                    device,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

To ensure that no work is active on the device, vkDeviceWaitIdle 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

VUID-vkDestroyDevice-device-00378
All child objects created on device must have been destroyed prior to destroying device
VUID-vkDestroyDevice-device-00379
If VkAllocationCallbacks were provided when device was created, a compatible set of callbacks must be provided here
VUID-vkDestroyDevice-device-00380
If no VkAllocationCallbacks were provided when device was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyDevice-device-parameter
If device is not NULL, device must be a valid VkDevice handle
VUID-vkDestroyDevice-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure

Host Synchronization

Host access to device must be externally synchronized

4.3. Queues

4.3.1. Queue Family Properties

As discussed in the Physical Device Enumeration section above, the vkGetPhysicalDeviceQueueFamilyProperties command is used to retrieve details about the queue families and queues supported by a device.

Each index in the pQueueFamilyProperties array returned by vkGetPhysicalDeviceQueueFamilyProperties describes a unique queue family on that physical device. These indices are used when creating queues, and they correspond directly with the queueFamilyIndex that is passed to the vkCreateDevice command via the VkDeviceQueueCreateInfo structure as described in the Queue Creation section below.

Grouping of queue families within a physical device is implementation-dependent.

Note

The general expectation is that a physical device groups all queues of matching capabilities into a single family. However, while implementations should do this, it is possible that a physical device may return two separate queue families with the same capabilities.

Once an application has identified a physical device with the queue(s) that it desires to use, it will create those queues in conjunction with a logical device. This is described in the following section.

4.3.2. Queue Creation

Creating a logical device also creates the queues associated with that device. The queues to create are described by a set of VkDeviceQueueCreateInfo structures that are passed to vkCreateDevice in pQueueCreateInfos.

Queues are represented by VkQueue handles:

VK_DEFINE_HANDLE(VkQueue)

The VkDeviceQueueCreateInfo structure is defined as:

typedef struct VkDeviceQueueCreateInfo {
    VkStructureType             sType;
    const void*                 pNext;
    VkDeviceQueueCreateFlags    flags;
    uint32_t                    queueFamilyIndex;
    uint32_t                    queueCount;
    const float*                pQueuePriorities;
} VkDeviceQueueCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask indicating behavior of the queue.
queueFamilyIndex is an unsigned integer indicating the index of the queue family to create on this device. This index corresponds to the index of an element of the pQueueFamilyProperties array that was returned by vkGetPhysicalDeviceQueueFamilyProperties.
queueCount is an unsigned integer specifying the number of queues to create in the queue family indicated by queueFamilyIndex.
pQueuePriorities is a pointer to an array of queueCount normalized floating point values, specifying priorities of work that will be submitted to each created queue. See Queue Priority for more information.

Valid Usage

VUID-VkDeviceQueueCreateInfo-queueFamilyIndex-00381
queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties
VUID-VkDeviceQueueCreateInfo-queueCount-00382
queueCount must be less than or equal to the queueCount member of the VkQueueFamilyProperties structure, as returned by vkGetPhysicalDeviceQueueFamilyProperties in the pQueueFamilyProperties[queueFamilyIndex]
VUID-VkDeviceQueueCreateInfo-pQueuePriorities-00383
Each element of pQueuePriorities must be between 0.0 and 1.0 inclusive
VUID-VkDeviceQueueCreateInfo-flags-02861
If the protected memory feature is not enabled, the VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT bit of flags must not be set.

Valid Usage (Implicit)

VUID-VkDeviceQueueCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
VUID-VkDeviceQueueCreateInfo-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkDeviceQueueGlobalPriorityCreateInfoEXT
VUID-VkDeviceQueueCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkDeviceQueueCreateInfo-flags-parameter
flags must be a valid combination of VkDeviceQueueCreateFlagBits values
VUID-VkDeviceQueueCreateInfo-pQueuePriorities-parameter
pQueuePriorities must be a valid pointer to an array of queueCount float values
VUID-VkDeviceQueueCreateInfo-queueCount-arraylength
queueCount must be greater than 0

Bits which can be set in VkDeviceQueueCreateInfo::flags to specify usage behavior of the queue are:

typedef enum VkDeviceQueueCreateFlagBits {
    VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001,
    VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkDeviceQueueCreateFlagBits;

VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT specifies that the device queue is a protected-capable queue.

typedef VkFlags VkDeviceQueueCreateFlags;

VkDeviceQueueCreateFlags is a bitmask type for setting a mask of zero or more VkDeviceQueueCreateFlagBits.

A queue can be created with a system-wide priority by adding a VkDeviceQueueGlobalPriorityCreateInfoEXT structure to the pNext chain of VkDeviceQueueCreateInfo.

The VkDeviceQueueGlobalPriorityCreateInfoEXT structure is defined as:

typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT {
    VkStructureType             sType;
    const void*                 pNext;
    VkQueueGlobalPriorityEXT    globalPriority;
} VkDeviceQueueGlobalPriorityCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
globalPriority is the system-wide priority associated to this queue as specified by VkQueueGlobalPriorityEXT

A queue created without specifying VkDeviceQueueGlobalPriorityCreateInfoEXT will default to VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT.

Valid Usage (Implicit)

VUID-VkDeviceQueueGlobalPriorityCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT
VUID-VkDeviceQueueGlobalPriorityCreateInfoEXT-globalPriority-parameter
globalPriority must be a valid VkQueueGlobalPriorityEXT value

Possible values of VkDeviceQueueGlobalPriorityCreateInfoEXT::globalPriority, specifying a system-wide priority level are:

typedef enum VkQueueGlobalPriorityEXT {
    VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128,
    VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256,
    VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512,
    VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024,
    VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF
} VkQueueGlobalPriorityEXT;

Priority values are sorted in ascending order. A comparison operation on the enum values can be used to determine the priority order.

VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT is below the system default. Useful for non-interactive tasks.
VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT is the system default priority.
VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT is above the system default.
VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT is the highest priority. Useful for critical tasks.

Queues with higher system priority may be allotted more processing time than queues with lower priority. An implementation may allow a higher-priority queue to starve a lower-priority queue until the higher-priority queue has no further commands to execute.

Priorities imply no ordering or scheduling constraints.

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

The global priority level of a queue takes precedence over the per-process queue priority (VkDeviceQueueCreateInfo::pQueuePriorities).

Abuse of this feature may result in starving the rest of the system of implementation resources. Therefore, the driver implementation may deny requests to acquire a priority above the default priority (VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT) if the caller does not have sufficient privileges. In this scenario VK_ERROR_NOT_PERMITTED_EXT is returned.

The driver implementation may fail the queue allocation request if resources required to complete the operation have been exhausted (either by the same process or a different process). In this scenario VK_ERROR_INITIALIZATION_FAILED is returned.

To retrieve a handle to a VkQueue object, call:

void vkGetDeviceQueue(
    VkDevice                                    device,
    uint32_t                                    queueFamilyIndex,
    uint32_t                                    queueIndex,
    VkQueue*                                    pQueue);

device is the logical device that owns the queue.
queueFamilyIndex is the index of the queue family to which the queue belongs.
queueIndex is the index within this queue family of the queue to retrieve.
pQueue is a pointer to a VkQueue object that will be filled with the handle for the requested queue.

vkGetDeviceQueue must only be used to get queues that were created with the flags parameter of VkDeviceQueueCreateInfo set to zero. To get queues that were created with a non-zero flags parameter use vkGetDeviceQueue2.

Valid Usage

VUID-vkGetDeviceQueue-queueFamilyIndex-00384
queueFamilyIndex must be one of the queue family indices specified when device was created, via the VkDeviceQueueCreateInfo structure
VUID-vkGetDeviceQueue-queueIndex-00385
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
VUID-vkGetDeviceQueue-flags-01841
VkDeviceQueueCreateInfo::flags must have been set to zero when device was created

Valid Usage (Implicit)

VUID-vkGetDeviceQueue-device-parameter
device must be a valid VkDevice handle
VUID-vkGetDeviceQueue-pQueue-parameter
pQueue must be a valid pointer to a VkQueue handle

To retrieve a handle to a VkQueue object with specific VkDeviceQueueCreateFlags creation flags, call:

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

device is the logical device that owns the queue.
pQueueInfo is a pointer to a VkDeviceQueueInfo2 structure, describing the parameters used to create the device queue.
pQueue is a pointer to a VkQueue object that will be filled with the handle for the requested queue.

Valid Usage (Implicit)

VUID-vkGetDeviceQueue2-device-parameter
device must be a valid VkDevice handle
VUID-vkGetDeviceQueue2-pQueueInfo-parameter
pQueueInfo must be a valid pointer to a valid VkDeviceQueueInfo2 structure
VUID-vkGetDeviceQueue2-pQueue-parameter
pQueue must be a valid pointer to a VkQueue handle

The VkDeviceQueueInfo2 structure is defined as:

typedef struct VkDeviceQueueInfo2 {
    VkStructureType             sType;
    const void*                 pNext;
    VkDeviceQueueCreateFlags    flags;
    uint32_t                    queueFamilyIndex;
    uint32_t                    queueIndex;
} VkDeviceQueueInfo2;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure. The pNext chain of VkDeviceQueueInfo2 is used to provide additional image parameters to vkGetDeviceQueue2.
flags is a VkDeviceQueueCreateFlags value indicating the flags used to create the device queue.
queueFamilyIndex is the index of the queue family to which the queue belongs.
queueIndex is the index within this queue family of the queue to retrieve.

The queue returned by vkGetDeviceQueue2 must have the same flags value from this structure as that used at device creation time in a VkDeviceQueueCreateInfo instance. If no matching flags were specified at device creation time then pQueue will return VK_NULL_HANDLE.

Valid Usage

VUID-VkDeviceQueueInfo2-queueFamilyIndex-01842
queueFamilyIndex must be one of the queue family indices specified when device was created, via the VkDeviceQueueCreateInfo structure
VUID-VkDeviceQueueInfo2-queueIndex-01843
queueIndex must be less than the number of queues created for the specified queue family index and VkDeviceQueueCreateFlags member flags equal to this flags value when device was created, via the queueCount member of the VkDeviceQueueCreateInfo structure

Valid Usage (Implicit)

VUID-VkDeviceQueueInfo2-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2
VUID-VkDeviceQueueInfo2-pNext-pNext
pNext must be NULL
VUID-VkDeviceQueueInfo2-flags-parameter
flags must be a valid combination of VkDeviceQueueCreateFlagBits values

4.3.3. Queue Family Index

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 as described in the previous section.

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 (see Images) and VkBuffer (see Buffers) 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 (see Pipeline Barriers), 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. See the Resource Sharing section for details.

4.3.4. Queue Priority

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 any explicit synchronization 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.

4.3.5. Queue Submission

Work is submitted to a queue via queue submission commands such as vkQueueSubmit. Queue submission commands define a set of queue operations to be executed by the underlying physical device, including synchronization with semaphores and fences.

Submission commands take as parameters a target queue, zero or more batches of work, and an optional fence to signal upon completion. Each batch consists of three distinct parts:

Zero or more semaphores to wait on before execution of the rest of the batch.
- If present, these describe a semaphore wait operation.
Zero or more work items to execute.
- If present, these describe a queue operation matching the work described.
Zero or more semaphores to signal upon completion of the work items.
- If present, these describe a semaphore signal operation.

If a fence is present in a queue submission, it describes a fence signal operation.

All work described by a queue submission command must be submitted to the queue before the command returns.

Sparse Memory Binding

In Vulkan it is possible to sparsely bind memory to buffers and images as described in the Sparse Resource chapter. Sparse memory binding is a queue operation. A queue whose flags include the VK_QUEUE_SPARSE_BINDING_BIT must be able to support the mapping of a virtual address to a physical address on the device. This causes an update to the page table mappings on the device. This update must be synchronized on a queue to avoid corrupting page table mappings during execution of graphics commands. By binding the sparse memory resources on queues, all commands that are dependent on the updated bindings are synchronized to only execute after the binding is updated. See the Synchronization and Cache Control chapter for how this synchronization is accomplished.

4.3.6. Queue Destruction

Queues are created along with a logical device during vkCreateDevice. All queues associated with a logical device are destroyed when vkDestroyDevice is called on that device.

5. Command Buffers

Command buffers are objects used to record commands which can be subsequently submitted to a device queue for execution. There are two levels of command buffers - primary command buffers, which can execute secondary command buffers, and which are submitted to queues, and secondary command buffers, which can be executed by primary command buffers, and which are not directly submitted to queues.

Command buffers are represented by VkCommandBuffer handles:

VK_DEFINE_HANDLE(VkCommandBuffer)

Recorded commands include commands to bind pipelines and descriptor sets to the command buffer, commands to modify dynamic state, commands to draw (for graphics rendering), commands to dispatch (for compute), commands to execute secondary command buffers (for primary command buffers only), commands to copy buffers and images, and other commands.

Each command buffer manages state independently of other command buffers. There is no inheritance of state across primary and secondary command buffers, or between secondary command buffers. When a command buffer begins recording, all state in that command buffer is undefined. When secondary command buffer(s) are recorded to execute on a primary command buffer, the secondary command buffer inherits no state from the primary command buffer, and all state of the primary command buffer is undefined after an execute secondary command buffer command is recorded. There is one exception to this rule - if the primary command buffer is inside a render pass instance, then the render pass and subpass state is not disturbed by executing secondary command buffers. For state dependent commands (such as draws and dispatches), any state consumed by those commands must not be undefined.

Unless otherwise specified, and without explicit synchronization, the various commands submitted to a queue via command buffers may execute in arbitrary order relative to each other, and/or concurrently. Also, the memory side-effects of those commands may not be directly visible to other commands without explicit memory dependencies. This is true within a command buffer, and across command buffers submitted to a given queue. See the synchronization chapter for information on implicit and explicit synchronization between commands.

5.1. Command Buffer Lifecycle

Each command buffer is always in one of the following states:

Initial: When a command buffer is allocated, it is in the initial state. Some commands are able to reset a command buffer (or a set of command buffers) back to this state from any of the executable, recording or invalid state. Command buffers in the initial state can only be moved to the recording state, or freed.
Recording: vkBeginCommandBuffer changes the state of a command buffer from the initial state to the recording state. Once a command buffer is in the recording state, vkCmd* commands can be used to record to the command buffer.
Executable: vkEndCommandBuffer ends the recording of a command buffer, and moves it from the recording state to the executable state. Executable command buffers can be submitted, reset, or recorded to another command buffer.
Pending: Queue submission of a command buffer changes the state of a command buffer from the executable state to the pending state. Whilst in the pending state, applications must not attempt to modify the command buffer in any way - as the device may be processing the commands recorded to it. Once execution of a command buffer completes, the command buffer either reverts back to the executable state, or if it was recorded with VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, it moves to the invalid state. A synchronization command should be used to detect when this occurs.
Invalid: Some operations, such as modifying or deleting a resource that was used in a command recorded to a command buffer, will transition the state of that command buffer into the invalid state. Command buffers in the invalid state can only be reset or freed.

Figure 1. Lifecycle of a command buffer

Any given command that operates on a command buffer has its own requirements on what state a command buffer must be in, which are detailed in the valid usage constraints for that command.

Resetting a command buffer is an operation that discards any previously recorded commands and puts a command buffer in the initial state. Resetting occurs as a result of vkResetCommandBuffer or vkResetCommandPool, or as part of vkBeginCommandBuffer (which additionally puts the command buffer in the recording state).

Secondary command buffers can be recorded to a primary command buffer via vkCmdExecuteCommands. This partially ties the lifecycle of the two command buffers together - if the primary is submitted to a queue, both the primary and any secondaries recorded to it move to the pending state. Once execution of the primary completes, so it does for any secondary recorded within it. After all executions of each command buffer complete, they each move to their appropriate completion state (either to the execution state or the invalid state, as specified above).

If a secondary moves to the invalid state or the initial state, then all primary buffers it is recorded in move to the invalid state. A primary moving to any other state does not affect the state of a secondary recorded in it.

Note

Resetting or freeing a primary command buffer removes the lifecycle linkage to all secondary command buffers that were recorded into it.

5.2. Command Pools

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 externally 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.

Command pools are represented by VkCommandPool handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)

To create a command pool, call:

VkResult vkCreateCommandPool(
    VkDevice                                    device,
    const VkCommandPoolCreateInfo*              pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkCommandPool*                              pCommandPool);

device is the logical device that creates the command pool.
pCreateInfo is a pointer to a VkCommandPoolCreateInfo structure specifying the state of the command pool object.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pCommandPool is a pointer to a VkCommandPool handle in which the created pool is returned.

Valid Usage

VUID-vkCreateCommandPool-queueFamilyIndex-01937
pCreateInfo->queueFamilyIndex must be the index of a queue family available in the logical device device.

Valid Usage (Implicit)

VUID-vkCreateCommandPool-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateCommandPool-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkCommandPoolCreateInfo structure
VUID-vkCreateCommandPool-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateCommandPool-pCommandPool-parameter
pCommandPool must be a valid pointer to a VkCommandPool handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkCommandPoolCreateInfo structure is defined as:

typedef struct VkCommandPoolCreateInfo {
    VkStructureType             sType;
    const void*                 pNext;
    VkCommandPoolCreateFlags    flags;
    uint32_t                    queueFamilyIndex;
} VkCommandPoolCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkCommandPoolCreateFlagBits indicating usage behavior for the pool and command buffers allocated from it.
queueFamilyIndex designates a queue family as described in section Queue Family Properties. All command buffers allocated from this command pool must be submitted on queues from the same queue family.

Valid Usage

VUID-VkCommandPoolCreateInfo-flags-02860
If the protected memory feature is not enabled, the VK_COMMAND_POOL_CREATE_PROTECTED_BIT bit of flags must not be set.

Valid Usage (Implicit)

VUID-VkCommandPoolCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
VUID-VkCommandPoolCreateInfo-pNext-pNext
pNext must be NULL
VUID-VkCommandPoolCreateInfo-flags-parameter
flags must be a valid combination of VkCommandPoolCreateFlagBits values

Bits which can be set in VkCommandPoolCreateInfo::flags to specify usage behavior for a command pool are:

typedef enum VkCommandPoolCreateFlagBits {
    VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
    VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
    VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004,
    VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkCommandPoolCreateFlagBits;

VK_COMMAND_POOL_CREATE_TRANSIENT_BIT specifies 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.
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT allows any command buffer allocated from a pool to be individually reset to the initial state; either by calling vkResetCommandBuffer, or via the implicit reset when calling vkBeginCommandBuffer. If this flag is not set on a pool, then vkResetCommandBuffer must not be called for any command buffer allocated from that pool.
VK_COMMAND_POOL_CREATE_PROTECTED_BIT specifies that command buffers allocated from the pool are protected command buffers.

typedef VkFlags VkCommandPoolCreateFlags;

VkCommandPoolCreateFlags is a bitmask type for setting a mask of zero or more VkCommandPoolCreateFlagBits.

To trim a command pool, call:

void vkTrimCommandPool(
    VkDevice                                    device,
    VkCommandPool                               commandPool,
    VkCommandPoolTrimFlags                      flags);

or the equivalent command

void vkTrimCommandPoolKHR(
    VkDevice                                    device,
    VkCommandPool                               commandPool,
    VkCommandPoolTrimFlags                      flags);

device is the logical device that owns the command pool.
commandPool is the command pool to trim.
flags is reserved for future use.

Trimming a command pool recycles unused memory from the command pool back to the system. Command buffers allocated from the pool are not affected by the command.

Note

This command provides applications with some control over the internal memory allocations used by command pools.

Unused memory normally arises from command buffers that have been recorded and later reset, such that they are no longer using the memory. On reset, a command buffer can return memory to its command pool, but the only way to release memory from a command pool to the system requires calling vkResetCommandPool, which cannot be executed while any command buffers from that pool are still in use. Subsequent recording operations into command buffers will re-use this memory but since total memory requirements fluctuate over time, unused memory can accumulate.

In this situation, trimming a command pool may be useful to return unused memory back to the system, returning the total outstanding memory allocated by the pool back to a more “average” value.

Implementations utilize many internal allocation strategies that make it impossible to guarantee that all unused memory is released back to the system. For instance, an implementation of a command pool may involve allocating memory in bulk from the system and sub-allocating from that memory. In such an implementation any live command buffer that holds a reference to a bulk allocation would prevent that allocation from being freed, even if only a small proportion of the bulk allocation is in use.

In most cases trimming will result in a reduction in allocated but unused memory, but it does not guarantee the “ideal” behavior.

Trimming may be an expensive operation, and should not be called frequently. Trimming should be treated as a way to relieve memory pressure after application-known points when there exists enough unused memory that the cost of trimming is “worth” it.

Valid Usage (Implicit)

VUID-vkTrimCommandPool-device-parameter
device must be a valid VkDevice handle
VUID-vkTrimCommandPool-commandPool-parameter
commandPool must be a valid VkCommandPool handle
VUID-vkTrimCommandPool-flags-zerobitmask
flags must be 0
VUID-vkTrimCommandPool-commandPool-parent
commandPool must have been created, allocated, or retrieved from device

Host Synchronization

Host access to commandPool must be externally synchronized

typedef VkFlags VkCommandPoolTrimFlags;

or the equivalent

typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR;

VkCommandPoolTrimFlags is a bitmask type for setting a mask, but is currently reserved for future use.

To reset a command pool, call:

VkResult vkResetCommandPool(
    VkDevice                                    device,
    VkCommandPool                               commandPool,
    VkCommandPoolResetFlags                     flags);

device is the logical device that owns the command pool.
commandPool is the command pool to reset.
flags is a bitmask of VkCommandPoolResetFlagBits controlling the reset operation.

Resetting a command pool recycles all of the resources from all of the command buffers allocated from the command pool back to the command pool. All command buffers that have been allocated from the command pool are put in the initial state.

Any primary command buffer allocated from another VkCommandPool that is in the recording or executable state and has a secondary command buffer allocated from commandPool recorded into it, becomes invalid.

Valid Usage

VUID-vkResetCommandPool-commandPool-00040
All VkCommandBuffer objects allocated from commandPool must not be in the pending state

Valid Usage (Implicit)

VUID-vkResetCommandPool-device-parameter
device must be a valid VkDevice handle
VUID-vkResetCommandPool-commandPool-parameter
commandPool must be a valid VkCommandPool handle
VUID-vkResetCommandPool-flags-parameter
flags must be a valid combination of VkCommandPoolResetFlagBits values
VUID-vkResetCommandPool-commandPool-parent
commandPool must have been created, allocated, or retrieved from device

Host Synchronization

Host access to commandPool must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Bits which can be set in vkResetCommandPool::flags to control the reset operation are:

typedef enum VkCommandPoolResetFlagBits {
    VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
    VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkCommandPoolResetFlagBits;

VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT specifies that resetting a command pool recycles all of the resources from the command pool back to the system.

typedef VkFlags VkCommandPoolResetFlags;

VkCommandPoolResetFlags is a bitmask type for setting a mask of zero or more VkCommandPoolResetFlagBits.

To destroy a command pool, call:

void vkDestroyCommandPool(
    VkDevice                                    device,
    VkCommandPool                               commandPool,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the command pool.
commandPool is the handle of the command pool to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

When a pool is destroyed, all command buffers allocated from the pool are freed.

Valid Usage

VUID-vkDestroyCommandPool-commandPool-00041
All VkCommandBuffer objects allocated from commandPool must not be in the pending state.
VUID-vkDestroyCommandPool-commandPool-00042
If VkAllocationCallbacks were provided when commandPool was created, a compatible set of callbacks must be provided here
VUID-vkDestroyCommandPool-commandPool-00043
If no VkAllocationCallbacks were provided when commandPool was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyCommandPool-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyCommandPool-commandPool-parameter
If commandPool is not VK_NULL_HANDLE, commandPool must be a valid VkCommandPool handle
VUID-vkDestroyCommandPool-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyCommandPool-commandPool-parent
If commandPool is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to commandPool must be externally synchronized

5.3. Command Buffer Allocation and Management

To allocate command buffers, call:

VkResult vkAllocateCommandBuffers(
    VkDevice                                    device,
    const VkCommandBufferAllocateInfo*          pAllocateInfo,
    VkCommandBuffer*                            pCommandBuffers);

device is the logical device that owns the command pool.
pAllocateInfo is a pointer to a VkCommandBufferAllocateInfo structure describing parameters of the allocation.
pCommandBuffers is a pointer to an array of VkCommandBuffer handles in which the resulting command buffer objects are returned. The array must be at least the length specified by the commandBufferCount member of pAllocateInfo. Each allocated command buffer begins in the initial state.

vkAllocateCommandBuffers can be used to create multiple command buffers. If the creation of any of those command buffers fails, the implementation must destroy all successfully created command buffer objects from this command, set all entries of the pCommandBuffers array to NULL and return the error.

When command buffers are first allocated, they are in the initial state.

Valid Usage (Implicit)

VUID-vkAllocateCommandBuffers-device-parameter
device must be a valid VkDevice handle
VUID-vkAllocateCommandBuffers-pAllocateInfo-parameter
pAllocateInfo must be a valid pointer to a valid VkCommandBufferAllocateInfo structure
VUID-vkAllocateCommandBuffers-pCommandBuffers-parameter
pCommandBuffers must be a valid pointer to an array of pAllocateInfo::commandBufferCount VkCommandBuffer handles
VUID-vkAllocateCommandBuffers-pAllocateInfo
::commandBufferCount-arraylength The value referenced by pAllocateInfo::commandBufferCount must be greater than 0

Host Synchronization

Host access to pAllocateInfo::commandPool must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkCommandBufferAllocateInfo structure is defined as:

typedef struct VkCommandBufferAllocateInfo {
    VkStructureType         sType;
    const void*             pNext;
    VkCommandPool           commandPool;
    VkCommandBufferLevel    level;
    uint32_t                commandBufferCount;
} VkCommandBufferAllocateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
commandPool is the command pool from which the command buffers are allocated.
level is a VkCommandBufferLevel value specifying the command buffer level.
commandBufferCount is the number of command buffers to allocate from the pool.

Valid Usage

VUID-VkCommandBufferAllocateInfo-commandBufferCount-00044
commandBufferCount must be greater than 0

Valid Usage (Implicit)

VUID-VkCommandBufferAllocateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
VUID-VkCommandBufferAllocateInfo-pNext-pNext
pNext must be NULL
VUID-VkCommandBufferAllocateInfo-commandPool-parameter
commandPool must be a valid VkCommandPool handle
VUID-VkCommandBufferAllocateInfo-level-parameter
level must be a valid VkCommandBufferLevel value

Possible values of VkCommandBufferAllocateInfo::level, specifying the command buffer level, are:

typedef enum VkCommandBufferLevel {
    VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
    VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
    VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
} VkCommandBufferLevel;

VK_COMMAND_BUFFER_LEVEL_PRIMARY specifies a primary command buffer.
VK_COMMAND_BUFFER_LEVEL_SECONDARY specifies a secondary command buffer.

To reset command buffers, call:

VkResult vkResetCommandBuffer(
    VkCommandBuffer                             commandBuffer,
    VkCommandBufferResetFlags                   flags);

commandBuffer is the command buffer to reset. The command buffer can be in any state other than pending, and is moved into the initial state.
flags is a bitmask of VkCommandBufferResetFlagBits controlling the reset operation.

Any primary command buffer that is in the recording or executable state and has commandBuffer recorded into it, becomes invalid.

Valid Usage

VUID-vkResetCommandBuffer-commandBuffer-00045
commandBuffer must not be in the pending state
VUID-vkResetCommandBuffer-commandBuffer-00046
commandBuffer must have been allocated from a pool that was created with the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT

Valid Usage (Implicit)

VUID-vkResetCommandBuffer-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkResetCommandBuffer-flags-parameter
flags must be a valid combination of VkCommandBufferResetFlagBits values

Host Synchronization

Host access to commandBuffer must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Bits which can be set in vkResetCommandBuffer::flags to control the reset operation are:

typedef enum VkCommandBufferResetFlagBits {
    VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
    VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkCommandBufferResetFlagBits;

VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT specifies that 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. commandBuffer is moved to the initial state.

typedef VkFlags VkCommandBufferResetFlags;

VkCommandBufferResetFlags is a bitmask type for setting a mask of zero or more VkCommandBufferResetFlagBits.

To free command buffers, call:

void vkFreeCommandBuffers(
    VkDevice                                    device,
    VkCommandPool                               commandPool,
    uint32_t                                    commandBufferCount,
    const VkCommandBuffer*                      pCommandBuffers);

device is the logical device that owns the command pool.
commandPool is the command pool from which the command buffers were allocated.
commandBufferCount is the length of the pCommandBuffers array.
pCommandBuffers is a pointer to an array of handles of command buffers to free.

Any primary command buffer that is in the recording or executable state and has any element of pCommandBuffers recorded into it, becomes invalid.

Valid Usage

VUID-vkFreeCommandBuffers-pCommandBuffers-00047
All elements of pCommandBuffers must not be in the pending state
VUID-vkFreeCommandBuffers-pCommandBuffers-00048
pCommandBuffers must be a valid pointer to an array of commandBufferCount VkCommandBuffer handles, each element of which must either be a valid handle or NULL

Valid Usage (Implicit)

VUID-vkFreeCommandBuffers-device-parameter
device must be a valid VkDevice handle
VUID-vkFreeCommandBuffers-commandPool-parameter
commandPool must be a valid VkCommandPool handle
VUID-vkFreeCommandBuffers-commandBufferCount-arraylength
commandBufferCount must be greater than 0
VUID-vkFreeCommandBuffers-commandPool-parent
commandPool must have been created, allocated, or retrieved from device
VUID-vkFreeCommandBuffers-pCommandBuffers-parent
Each element of pCommandBuffers that is a valid handle must have been created, allocated, or retrieved from commandPool

Host Synchronization

Host access to commandPool must be externally synchronized
Host access to each member of pCommandBuffers must be externally synchronized

5.4. Command Buffer Recording

To begin recording a command buffer, call:

VkResult vkBeginCommandBuffer(
    VkCommandBuffer                             commandBuffer,
    const VkCommandBufferBeginInfo*             pBeginInfo);

commandBuffer is the handle of the command buffer which is to be put in the recording state.
pBeginInfo points to a VkCommandBufferBeginInfo structure defining additional information about how the command buffer begins recording.

Valid Usage

VUID-vkBeginCommandBuffer-commandBuffer-00049
commandBuffer must not be in the recording or pending state
VUID-vkBeginCommandBuffer-commandBuffer-00050
If commandBuffer was allocated from a VkCommandPool which did not have the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT flag set, commandBuffer must be in the initial state
VUID-vkBeginCommandBuffer-commandBuffer-00051
If commandBuffer is a secondary command buffer, the pInheritanceInfo member of pBeginInfo must be a valid VkCommandBufferInheritanceInfo structure
VUID-vkBeginCommandBuffer-commandBuffer-00052
If commandBuffer is a secondary command buffer and either the occlusionQueryEnable member of the pInheritanceInfo member of pBeginInfo is VK_FALSE, or the precise occlusion queries feature is not enabled, the queryFlags member of the pInheritanceInfo member pBeginInfo must not contain VK_QUERY_CONTROL_PRECISE_BIT
VUID-vkBeginCommandBuffer-commandBuffer-02840
If commandBuffer is a primary command buffer, then pBeginInfo->flags must not set both the VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT and the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flags

Valid Usage (Implicit)

VUID-vkBeginCommandBuffer-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkBeginCommandBuffer-pBeginInfo-parameter
pBeginInfo must be a valid pointer to a valid VkCommandBufferBeginInfo structure

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkCommandBufferBeginInfo structure is defined as:

typedef struct VkCommandBufferBeginInfo {
    VkStructureType                          sType;
    const void*                              pNext;
    VkCommandBufferUsageFlags                flags;
    const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
} VkCommandBufferBeginInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkCommandBufferUsageFlagBits specifying usage behavior for the command buffer.
pInheritanceInfo is a pointer to a VkCommandBufferInheritanceInfo structure, used if commandBuffer is a secondary command buffer. If this is a primary command buffer, then this value is ignored.

Valid Usage

VUID-VkCommandBufferBeginInfo-flags-00053
If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the renderPass member of pInheritanceInfo must be a valid VkRenderPass
VUID-VkCommandBufferBeginInfo-flags-00054
If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the subpass member of pInheritanceInfo must be a valid subpass index within the renderPass member of pInheritanceInfo
VUID-VkCommandBufferBeginInfo-flags-00055
If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the framebuffer member of pInheritanceInfo must be either VK_NULL_HANDLE, or a valid VkFramebuffer that is compatible with the renderPass member of pInheritanceInfo

Valid Usage (Implicit)

VUID-VkCommandBufferBeginInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
VUID-VkCommandBufferBeginInfo-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkDeviceGroupCommandBufferBeginInfo
VUID-VkCommandBufferBeginInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkCommandBufferBeginInfo-flags-parameter
flags must be a valid combination of VkCommandBufferUsageFlagBits values

Bits which can be set in VkCommandBufferBeginInfo::flags to specify usage behavior for a command buffer are:

typedef enum VkCommandBufferUsageFlagBits {
    VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
    VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
    VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkCommandBufferUsageFlagBits;

VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT specifies 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.
VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT specifies 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.
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT specifies that a command buffer can be resubmitted to a queue while it is in the pending state, and recorded into multiple primary command buffers.

typedef VkFlags VkCommandBufferUsageFlags;

VkCommandBufferUsageFlags is a bitmask type for setting a mask of zero or more VkCommandBufferUsageFlagBits.

If the command buffer is a secondary command buffer, then the VkCommandBufferInheritanceInfo structure defines any state that will be inherited from the primary command buffer:

typedef struct VkCommandBufferInheritanceInfo {
    VkStructureType                  sType;
    const void*                      pNext;
    VkRenderPass                     renderPass;
    uint32_t                         subpass;
    VkFramebuffer                    framebuffer;
    VkBool32                         occlusionQueryEnable;
    VkQueryControlFlags              queryFlags;
    VkQueryPipelineStatisticFlags    pipelineStatistics;
} VkCommandBufferInheritanceInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
renderPass is a VkRenderPass object defining which render passes the VkCommandBuffer will be compatible with and can be executed within. If the VkCommandBuffer will not be executed within a render pass instance, renderPass is ignored.
subpass is the index of the subpass within the render pass instance that the VkCommandBuffer will be executed within. If the VkCommandBuffer will not be executed within a render pass instance, subpass is ignored.
framebuffer optionally refers to the VkFramebuffer object that the VkCommandBuffer will be rendering to if it is executed within a render pass instance. It can be VK_NULL_HANDLE if the framebuffer is not known, or if the VkCommandBuffer will not be executed within a render pass instance.

Note

Specifying the exact framebuffer that the secondary command buffer will be executed with may result in better performance at command buffer execution time.
occlusionQueryEnable specifies whether the command buffer can be executed while an occlusion query is active in the primary command buffer. If this is VK_TRUE, then this command buffer can be executed whether the primary command buffer has an occlusion query active or not. If this is VK_FALSE, then the primary command buffer must not have an occlusion query active.
queryFlags specifies the query flags that can be used by an active occlusion query in the primary command buffer when this secondary command buffer is executed. If this value includes the VK_QUERY_CONTROL_PRECISE_BIT bit, then the active query can return boolean results or actual sample counts. If this bit is not set, then the active query must not use the VK_QUERY_CONTROL_PRECISE_BIT bit.
pipelineStatistics is a bitmask of VkQueryPipelineStatisticFlagBits specifying the set of pipeline statistics that can be counted by an active query in the primary command buffer when this secondary command buffer is executed. If this value includes a given bit, then this command buffer can be executed whether the primary command buffer has a pipeline statistics query active that includes this bit or not. If this value excludes a given bit, then the active pipeline statistics query must not be from a query pool that counts that statistic.

Valid Usage

VUID-VkCommandBufferInheritanceInfo-occlusionQueryEnable-00056
If the inherited queries feature is not enabled, occlusionQueryEnable must be VK_FALSE
VUID-VkCommandBufferInheritanceInfo-queryFlags-00057
If the inherited queries feature is enabled, queryFlags must be a valid combination of VkQueryControlFlagBits values
VUID-VkCommandBufferInheritanceInfo-queryFlags-02788
If the inherited queries feature is not enabled, queryFlags must be 0
VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-02789
If the pipeline statistics queries feature is enabled, pipelineStatistics must be a valid combination of VkQueryPipelineStatisticFlagBits values
VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-00058
If the pipeline statistics queries feature is not enabled, pipelineStatistics must be 0

Valid Usage (Implicit)

VUID-VkCommandBufferInheritanceInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO
VUID-VkCommandBufferInheritanceInfo-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkCommandBufferInheritanceConditionalRenderingInfoEXT
VUID-VkCommandBufferInheritanceInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkCommandBufferInheritanceInfo-commonparent
Both of framebuffer, and renderPass that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

Note

On some implementations, not using the VK_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 invalid, or executable state, and the command buffer was allocated from a command pool with the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT flag set, then vkBeginCommandBuffer implicitly resets the command buffer, behaving as if vkResetCommandBuffer had been called with VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT not set. After the implicit reset, commandBuffer is moved to the recording state.

If the pNext chain of VkCommandBufferInheritanceInfo includes a VkCommandBufferInheritanceConditionalRenderingInfoEXT structure, then that structure controls whether a command buffer can be executed while conditional rendering is active in the primary command buffer.

The VkCommandBufferInheritanceConditionalRenderingInfoEXT structure is defined as:

typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT {
    VkStructureType    sType;
    const void*        pNext;
    VkBool32           conditionalRenderingEnable;
} VkCommandBufferInheritanceConditionalRenderingInfoEXT;

sType is the type of this structure
pNext is NULL or a pointer to an extension-specific structure
conditionalRenderingEnable specifies whether the command buffer can be executed while conditional rendering is active in the primary command buffer. If this is VK_TRUE, then this command buffer can be executed whether the primary command buffer has active conditional rendering or not. If this is VK_FALSE, then the primary command buffer must not have conditional rendering active.

If this structure is not present, the behavior is as if conditionalRenderingEnable is VK_FALSE.

Valid Usage

VUID-VkCommandBufferInheritanceConditionalRenderingInfoEXT-conditionalRenderingEnable-01977
If the inherited conditional rendering feature is not enabled, conditionalRenderingEnable must be VK_FALSE

Valid Usage (Implicit)

VUID-VkCommandBufferInheritanceConditionalRenderingInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT

Once recording starts, an application records a sequence of commands (vkCmd*) to set state in the command buffer, draw, dispatch, and other commands.

Several commands can also be recorded indirectly from VkBuffer content, see Device-Generated Commands.

To complete recording of a command buffer, call:

VkResult vkEndCommandBuffer(
    VkCommandBuffer                             commandBuffer);

commandBuffer is the command buffer to complete recording.

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. The command buffer must have been in the recording state, and is moved to the executable state.

Valid Usage

VUID-vkEndCommandBuffer-commandBuffer-00059
commandBuffer must be in the recording state.
VUID-vkEndCommandBuffer-commandBuffer-00060
If commandBuffer is a primary command buffer, there must not be an active render pass instance
VUID-vkEndCommandBuffer-commandBuffer-00061
All queries made active during the recording of commandBuffer must have been made inactive
VUID-vkEndCommandBuffer-None-01978
Conditional rendering must not be active
VUID-vkEndCommandBuffer-commandBuffer-01815
If commandBuffer is a secondary command buffer, there must not be an outstanding vkCmdBeginDebugUtilsLabelEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdEndDebugUtilsLabelEXT.
VUID-vkEndCommandBuffer-commandBuffer-00062
If commandBuffer is a secondary command buffer, there must not be an outstanding vkCmdDebugMarkerBeginEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdDebugMarkerEndEXT.

Valid Usage (Implicit)

VUID-vkEndCommandBuffer-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

When a command buffer is in the executable state, it can be submitted to a queue for execution.

5.5. Command Buffer Submission

To submit command buffers to a queue, call:

VkResult vkQueueSubmit(
    VkQueue                                     queue,
    uint32_t                                    submitCount,
    const VkSubmitInfo*                         pSubmits,
    VkFence                                     fence);

queue is the queue that the command buffers will be submitted to.
submitCount is the number of elements in the pSubmits array.
pSubmits is a pointer to an array of VkSubmitInfo structures, each specifying a command buffer submission batch.
fence is an optional handle to a fence to be signaled once all submitted command buffers have completed execution. If fence is not VK_NULL_HANDLE, it defines a fence signal operation.

Note

Submission can be a high overhead operation, and applications should attempt to batch work together into as few calls to vkQueueSubmit as possible.

vkQueueSubmit is a queue submission command, with each batch defined by an element of pSubmits. Batches begin execution in the order they appear in pSubmits, but may complete out of order.

Fence and semaphore operations submitted with vkQueueSubmit have additional ordering constraints compared to other submission commands, with dependencies involving previous and subsequent queue operations. Information about these additional constraints can be found in the semaphore and fence sections of the synchronization chapter.

Details on the interaction of pWaitDstStageMask with synchronization are described in the semaphore wait operation section of the synchronization chapter.

The order that batches appear in pSubmits is used to determine submission order, and thus all the implicit ordering guarantees that respect it. Other than these implicit ordering guarantees and any explicit synchronization primitives, these batches may overlap or otherwise execute out of order.

If any command buffer submitted to this queue is in the executable state, it is moved to the pending state. Once execution of all submissions of a command buffer complete, it moves from the pending state, back to the executable state. If a command buffer was recorded with the VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT flag, it instead moves to the invalid state.

If vkQueueSubmit fails, it may return VK_ERROR_OUT_OF_HOST_MEMORY or VK_ERROR_OUT_OF_DEVICE_MEMORY. If it does, the implementation must ensure that the state and contents of any resources or synchronization primitives referenced by the submitted command buffers and any semaphores referenced by pSubmits is unaffected by the call or its failure. If vkQueueSubmit fails in such a way that the implementation is unable to make that guarantee, the implementation must return VK_ERROR_DEVICE_LOST. See Lost Device.

Valid Usage

VUID-vkQueueSubmit-fence-00063
If fence is not VK_NULL_HANDLE, fence must be unsignaled
VUID-vkQueueSubmit-fence-00064
If fence is not VK_NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue
VUID-vkQueueSubmit-pCommandBuffers-00065
Any calls to vkCmdSetEvent, vkCmdResetEvent or vkCmdWaitEvents that have been recorded into any of the command buffer elements of the pCommandBuffers member of any element of pSubmits, must not reference any VkEvent that is referenced by any of those commands in a command buffer that has been submitted to another queue and is still in the pending state
VUID-vkQueueSubmit-pWaitDstStageMask-00066
Any stage flag included in any element of the pWaitDstStageMask member of any element of pSubmits must be a pipeline stage supported by one of the capabilities of queue, as specified in the table of supported pipeline stages
VUID-vkQueueSubmit-pSignalSemaphores-00067
Each element of the pSignalSemaphores member of any element of pSubmits must be unsignaled when the semaphore signal operation it defines is executed on the device
VUID-vkQueueSubmit-pWaitSemaphores-00068
When a semaphore wait operation referring to a binary semaphore defined by any element of the pWaitSemaphores member of any element of pSubmits executes on queue, there must be no other queues waiting on the same semaphore
VUID-vkQueueSubmit-pWaitSemaphores-03238
All elements of the pWaitSemaphores member of all elements of pSubmits created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY must reference a semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) must have also been submitted for execution
VUID-vkQueueSubmit-pCommandBuffers-00070
Each element of the pCommandBuffers member of each element of pSubmits must be in the pending or executable state
VUID-vkQueueSubmit-pCommandBuffers-00071
If any element of the pCommandBuffers member of any element of pSubmits was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, it must not be in the pending state
VUID-vkQueueSubmit-pCommandBuffers-00072
Any secondary command buffers recorded into any element of the pCommandBuffers member of any element of pSubmits must be in the pending or executable state
VUID-vkQueueSubmit-pCommandBuffers-00073
If any secondary command buffers recorded into any element of the pCommandBuffers member of any element of pSubmits was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, it must not be in the pending state
VUID-vkQueueSubmit-pCommandBuffers-00074
Each element of the pCommandBuffers member of each element of pSubmits must have been allocated from a VkCommandPool that was created for the same queue family queue belongs to
VUID-vkQueueSubmit-pSubmits-02207
If any element of pSubmits->pCommandBuffers includes a Queue Family Transfer Acquire Operation, there must exist a previously submitted Queue Family Transfer Release Operation on a queue in the queue family identified by the acquire operation, with parameters matching the acquire operation as defined in the definition of such acquire operations, and which happens before the acquire operation
VUID-vkQueueSubmit-pCommandBuffers-03220
If a command recorded into any element of pCommandBuffers was a vkCmdBeginQuery whose queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the profiling lock must have been held continuously on the VkDevice that queue was retrieved from, throughout recording of those command buffers
VUID-vkQueueSubmit-pSubmits-02808
Any resource created with VK_SHARING_MODE_EXCLUSIVE that is read by an operation specified by pSubmits must not be owned by any queue family other than the one which queue belongs to, at the time it is executed

Valid Usage (Implicit)

VUID-vkQueueSubmit-queue-parameter
queue must be a valid VkQueue handle
VUID-vkQueueSubmit-pSubmits-parameter
If submitCount is not 0, pSubmits must be a valid pointer to an array of submitCount valid VkSubmitInfo structures
VUID-vkQueueSubmit-fence-parameter
If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle
VUID-vkQueueSubmit-commonparent
Both of fence, and queue that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to queue must be externally synchronized
Host access to fence must be externally synchronized

Command Properties

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
-	-	Any	-

Any

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST

The VkSubmitInfo structure is defined as:

typedef struct VkSubmitInfo {
    VkStructureType                sType;
    const void*                    pNext;
    uint32_t                       waitSemaphoreCount;
    const VkSemaphore*             pWaitSemaphores;
    const VkPipelineStageFlags*    pWaitDstStageMask;
    uint32_t                       commandBufferCount;
    const VkCommandBuffer*         pCommandBuffers;
    uint32_t                       signalSemaphoreCount;
    const VkSemaphore*             pSignalSemaphores;
} VkSubmitInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
waitSemaphoreCount is the number of semaphores upon which to wait before executing the command buffers for the batch.
pWaitSemaphores is a pointer to an array of VkSemaphore handles upon which to wait before the command buffers for this batch begin execution. If semaphores to wait on are provided, they define a semaphore wait operation.
pWaitDstStageMask is a pointer to an array of pipeline stages at which each corresponding semaphore wait will occur.
commandBufferCount is the number of command buffers to execute in the batch.
pCommandBuffers is a pointer to an array of VkCommandBuffer handles to execute in the batch.
signalSemaphoreCount is the number of semaphores to be signaled once the commands specified in pCommandBuffers have completed execution.
pSignalSemaphores is a pointer to an array of VkSemaphore handles which will be signaled when the command buffers for this batch have completed execution. If semaphores to be signaled are provided, they define a semaphore signal operation.

The order that command buffers appear in pCommandBuffers is used to determine submission order, and thus all the implicit ordering guarantees that respect it. Other than these implicit ordering guarantees and any explicit synchronization primitives, these command buffers may overlap or otherwise execute out of order.

Valid Usage

VUID-VkSubmitInfo-pCommandBuffers-00075
Each element of pCommandBuffers must not have been allocated with VK_COMMAND_BUFFER_LEVEL_SECONDARY
VUID-VkSubmitInfo-pWaitDstStageMask-00076
If the geometry shaders feature is not enabled, each element of pWaitDstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
VUID-VkSubmitInfo-pWaitDstStageMask-00077
If the tessellation shaders feature is not enabled, each element of pWaitDstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
VUID-VkSubmitInfo-pWaitDstStageMask-00078
Each element of pWaitDstStageMask must not include VK_PIPELINE_STAGE_HOST_BIT.
VUID-VkSubmitInfo-pWaitSemaphores-03239
If any element of pWaitSemaphores or pSignalSemaphores was created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE, then the pNext chain must include a VkTimelineSemaphoreSubmitInfo structure
VUID-VkSubmitInfo-pNext-03240
If the pNext chain of this structure includes a VkTimelineSemaphoreSubmitInfo structure and any element of pWaitSemaphores was created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE, then its waitSemaphoreValueCount member must equal waitSemaphoreCount
VUID-VkSubmitInfo-pNext-03241
If the pNext chain of this structure includes a VkTimelineSemaphoreSubmitInfo structure and any element of pSignalSemaphores was created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE, then its signalSemaphoreValueCount member must equal signalSemaphoreCount
VUID-VkSubmitInfo-pSignalSemaphores-03242
For each element of pSignalSemaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE the corresponding element of VkTimelineSemaphoreSubmitInfo::pSignalSemaphoreValues must have a value greater than the current value of the semaphore when the semaphore signal operation is executed
VUID-VkSubmitInfo-pWaitSemaphores-03243
For each element of pWaitSemaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE the corresponding element of VkTimelineSemaphoreSubmitInfo::pWaitSemaphoreValues must have a value which does not differ from the current value of the semaphore or the value of any outstanding semaphore wait or signal operation on that semaphore by more than maxTimelineSemaphoreValueDifference.
VUID-VkSubmitInfo-pSignalSemaphores-03244
For each element of pSignalSemaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE the corresponding element of VkTimelineSemaphoreSubmitInfo::pSignalSemaphoreValues must have a value which does not differ from the current value of the semaphore or the value of any outstanding semaphore wait or signal operation on that semaphore by more than maxTimelineSemaphoreValueDifference.
VUID-VkSubmitInfo-pWaitDstStageMask-02089
If the mesh shaders feature is not enabled, each element of pWaitDstStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV
VUID-VkSubmitInfo-pWaitDstStageMask-02090
If the task shaders feature is not enabled, each element of pWaitDstStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV

Valid Usage (Implicit)

VUID-VkSubmitInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_SUBMIT_INFO
VUID-VkSubmitInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkD3D12FenceSubmitInfoKHR, VkDeviceGroupSubmitInfo, VkPerformanceQuerySubmitInfoKHR, VkProtectedSubmitInfo, VkTimelineSemaphoreSubmitInfo, VkWin32KeyedMutexAcquireReleaseInfoKHR, or VkWin32KeyedMutexAcquireReleaseInfoNV
VUID-VkSubmitInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkSubmitInfo-pWaitSemaphores-parameter
If waitSemaphoreCount is not 0, pWaitSemaphores must be a valid pointer to an array of waitSemaphoreCount valid VkSemaphore handles
VUID-VkSubmitInfo-pWaitDstStageMask-parameter
If waitSemaphoreCount is not 0, pWaitDstStageMask must be a valid pointer to an array of waitSemaphoreCount valid combinations of VkPipelineStageFlagBits values
VUID-VkSubmitInfo-pWaitDstStageMask-requiredbitmask
Each element of pWaitDstStageMask must not be 0
VUID-VkSubmitInfo-pCommandBuffers-parameter
If commandBufferCount is not 0, pCommandBuffers must be a valid pointer to an array of commandBufferCount valid VkCommandBuffer handles
VUID-VkSubmitInfo-pSignalSemaphores-parameter
If signalSemaphoreCount is not 0, pSignalSemaphores must be a valid pointer to an array of signalSemaphoreCount valid VkSemaphore handles
VUID-VkSubmitInfo-commonparent
Each of the elements of pCommandBuffers, the elements of pSignalSemaphores, and the elements of pWaitSemaphores that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

To specify the values to use when waiting for and signaling semaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE, add a VkTimelineSemaphoreSubmitInfo structure to the pNext chain of the VkSubmitInfo structure when using vkQueueSubmit or the VkBindSparseInfo structure when using vkQueueBindSparse. The VkTimelineSemaphoreSubmitInfo structure is defined as:

typedef struct VkTimelineSemaphoreSubmitInfo {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           waitSemaphoreValueCount;
    const uint64_t*    pWaitSemaphoreValues;
    uint32_t           signalSemaphoreValueCount;
    const uint64_t*    pSignalSemaphoreValues;
} VkTimelineSemaphoreSubmitInfo;

or the equivalent

typedef VkTimelineSemaphoreSubmitInfo VkTimelineSemaphoreSubmitInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
waitSemaphoreValueCount is the number of semaphore wait values specified in pWaitSemaphoreValues.
pWaitSemaphoreValues is an array of length waitSemaphoreValueCount containing values for the corresponding semaphores in VkSubmitInfo::pWaitSemaphores to wait for.
signalSemaphoreValueCount is the number of semaphore signal values specified in pSignalSemaphoreValues.
pSignalSemaphoreValues is an array of length signalSemaphoreValueCount containing values for the corresponding semaphores in VkSubmitInfo::pSignalSemaphores to set when signaled.

If the semaphore in VkSubmitInfo::pWaitSemaphores or VkSubmitInfo::pSignalSemaphores corresponding to an entry in pWaitSemaphoreValues or pSignalSemaphoreValues respectively was not created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE, the implementation must ignore the value in the pWaitSemaphoreValues or pSignalSemaphoreValues entry.

Valid Usage (Implicit)

VUID-VkTimelineSemaphoreSubmitInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO
VUID-VkTimelineSemaphoreSubmitInfo-pWaitSemaphoreValues-parameter
If waitSemaphoreValueCount is not 0, and pWaitSemaphoreValues is not NULL, pWaitSemaphoreValues must be a valid pointer to an array of waitSemaphoreValueCount uint64_t values
VUID-VkTimelineSemaphoreSubmitInfo-pSignalSemaphoreValues-parameter
If signalSemaphoreValueCount is not 0, and pSignalSemaphoreValues is not NULL, pSignalSemaphoreValues must be a valid pointer to an array of signalSemaphoreValueCount uint64_t values

To specify the values to use when waiting for and signaling semaphores whose current payload refers to a Direct3D 12 fence, add a VkD3D12FenceSubmitInfoKHR structure to the pNext chain of the VkSubmitInfo structure. The VkD3D12FenceSubmitInfoKHR structure is defined as:

typedef struct VkD3D12FenceSubmitInfoKHR {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           waitSemaphoreValuesCount;
    const uint64_t*    pWaitSemaphoreValues;
    uint32_t           signalSemaphoreValuesCount;
    const uint64_t*    pSignalSemaphoreValues;
} VkD3D12FenceSubmitInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
waitSemaphoreValuesCount is the number of semaphore wait values specified in pWaitSemaphoreValues.
pWaitSemaphoreValues is a pointer to an array of waitSemaphoreValuesCount values for the corresponding semaphores in VkSubmitInfo::pWaitSemaphores to wait for.
signalSemaphoreValuesCount is the number of semaphore signal values specified in pSignalSemaphoreValues.
pSignalSemaphoreValues is a pointer to an array of signalSemaphoreValuesCount values for the corresponding semaphores in VkSubmitInfo::pSignalSemaphores to set when signaled.

If the semaphore in VkSubmitInfo::pWaitSemaphores or VkSubmitInfo::pSignalSemaphores corresponding to an entry in pWaitSemaphoreValues or pSignalSemaphoreValues respectively does not currently have a payload referring to a Direct3D 12 fence, the implementation must ignore the value in the pWaitSemaphoreValues or pSignalSemaphoreValues entry.

Note

As the introduction of the external semaphore handle type VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT predates that of timeline semaphores, support for importing semaphore payloads from external handles of that type into semaphores created (implicitly or explicitly) with a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY is preserved for backwards compatibility. However, applications should prefer importing such handle types into semaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE, and use the VkTimelineSemaphoreSubmitInfo structure instead of the VkD3D12FenceSubmitInfoKHR structure to specify the values to use when waiting for and signaling such semaphores.

Valid Usage

VUID-VkD3D12FenceSubmitInfoKHR-waitSemaphoreValuesCount-00079
waitSemaphoreValuesCount must be the same value as VkSubmitInfo::waitSemaphoreCount, where VkSubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHR structure.
VUID-VkD3D12FenceSubmitInfoKHR-signalSemaphoreValuesCount-00080
signalSemaphoreValuesCount must be the same value as VkSubmitInfo::signalSemaphoreCount, where VkSubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHR structure.

Valid Usage (Implicit)

VUID-VkD3D12FenceSubmitInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR
VUID-VkD3D12FenceSubmitInfoKHR-pWaitSemaphoreValues-parameter
If waitSemaphoreValuesCount is not 0, and pWaitSemaphoreValues is not NULL, pWaitSemaphoreValues must be a valid pointer to an array of waitSemaphoreValuesCount uint64_t values
VUID-VkD3D12FenceSubmitInfoKHR-pSignalSemaphoreValues-parameter
If signalSemaphoreValuesCount is not 0, and pSignalSemaphoreValues is not NULL, pSignalSemaphoreValues must be a valid pointer to an array of signalSemaphoreValuesCount uint64_t values

When submitting work that operates on memory imported from a Direct3D 11 resource to a queue, the keyed mutex mechanism may be used in addition to Vulkan semaphores to synchronize the work. Keyed mutexes are a property of a properly created shareable Direct3D 11 resource. They can only be used if the imported resource was created with the D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX flag.

To acquire keyed mutexes before submitted work and/or release them after, add a VkWin32KeyedMutexAcquireReleaseInfoKHR structure to the pNext chain of the VkSubmitInfo structure.

The VkWin32KeyedMutexAcquireReleaseInfoKHR structure is defined as:

typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
    VkStructureType          sType;
    const void*              pNext;
    uint32_t                 acquireCount;
    const VkDeviceMemory*    pAcquireSyncs;
    const uint64_t*          pAcquireKeys;
    const uint32_t*          pAcquireTimeouts;
    uint32_t                 releaseCount;
    const VkDeviceMemory*    pReleaseSyncs;
    const uint64_t*          pReleaseKeys;
} VkWin32KeyedMutexAcquireReleaseInfoKHR;

acquireCount is the number of entries in the pAcquireSyncs, pAcquireKeys, and pAcquireTimeoutMilliseconds arrays.
pAcquireSyncs is a pointer to an array of VkDeviceMemory objects which were imported from Direct3D 11 resources.
pAcquireKeys is a pointer to an array of mutex key values to wait for prior to beginning the submitted work. Entries refer to the keyed mutex associated with the corresponding entries in pAcquireSyncs.
pAcquireTimeoutMilliseconds is a pointer to an array of timeout values, in millisecond units, for each acquire specified in pAcquireKeys.
releaseCount is the number of entries in the pReleaseSyncs and pReleaseKeys arrays.
pReleaseSyncs is a pointer to an array of VkDeviceMemory objects which were imported from Direct3D 11 resources.
pReleaseKeys is a pointer to an array of mutex key values to set when the submitted work has completed. Entries refer to the keyed mutex associated with the corresponding entries in pReleaseSyncs.

Valid Usage

VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-00081
Each member of pAcquireSyncs and pReleaseSyncs must be a device memory object imported by setting VkImportMemoryWin32HandleInfoKHR::handleType to VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT.

Valid Usage (Implicit)

VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR
VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-parameter
If acquireCount is not 0, pAcquireSyncs must be a valid pointer to an array of acquireCount valid VkDeviceMemory handles
VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireKeys-parameter
If acquireCount is not 0, pAcquireKeys must be a valid pointer to an array of acquireCount uint64_t values
VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireTimeouts-parameter
If acquireCount is not 0, pAcquireTimeouts must be a valid pointer to an array of acquireCount uint32_t values
VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pReleaseSyncs-parameter
If releaseCount is not 0, pReleaseSyncs must be a valid pointer to an array of releaseCount valid VkDeviceMemory handles
VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pReleaseKeys-parameter
If releaseCount is not 0, pReleaseKeys must be a valid pointer to an array of releaseCount uint64_t values
VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-commonparent
Both of the elements of pAcquireSyncs, and the elements of pReleaseSyncs that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

To acquire keyed mutexes before submitted work and/or release them after, add a VkWin32KeyedMutexAcquireReleaseInfoNV structure to the pNext chain of the VkSubmitInfo structure.

The VkWin32KeyedMutexAcquireReleaseInfoNV structure is defined as:

typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
    VkStructureType          sType;
    const void*              pNext;
    uint32_t                 acquireCount;
    const VkDeviceMemory*    pAcquireSyncs;
    const uint64_t*          pAcquireKeys;
    const uint32_t*          pAcquireTimeoutMilliseconds;
    uint32_t                 releaseCount;
    const VkDeviceMemory*    pReleaseSyncs;
    const uint64_t*          pReleaseKeys;
} VkWin32KeyedMutexAcquireReleaseInfoNV;

acquireCount is the number of entries in the pAcquireSyncs, pAcquireKeys, and pAcquireTimeoutMilliseconds arrays.
pAcquireSyncs is a pointer to an array of VkDeviceMemory objects which were imported from Direct3D 11 resources.
pAcquireKeys is a pointer to an array of mutex key values to wait for prior to beginning the submitted work. Entries refer to the keyed mutex associated with the corresponding entries in pAcquireSyncs.
pAcquireTimeoutMilliseconds is a pointer to an array of timeout values, in millisecond units, for each acquire specified in pAcquireKeys.
releaseCount is the number of entries in the pReleaseSyncs and pReleaseKeys arrays.
pReleaseSyncs is a pointer to an array of VkDeviceMemory objects which were imported from Direct3D 11 resources.
pReleaseKeys is a pointer to an array of mutex key values to set when the submitted work has completed. Entries refer to the keyed mutex associated with the corresponding entries in pReleaseSyncs.

Valid Usage (Implicit)

VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV
VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireSyncs-parameter
If acquireCount is not 0, pAcquireSyncs must be a valid pointer to an array of acquireCount valid VkDeviceMemory handles
VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireKeys-parameter
If acquireCount is not 0, pAcquireKeys must be a valid pointer to an array of acquireCount uint64_t values
VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireTimeoutMilliseconds-parameter
If acquireCount is not 0, pAcquireTimeoutMilliseconds must be a valid pointer to an array of acquireCount uint32_t values
VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pReleaseSyncs-parameter
If releaseCount is not 0, pReleaseSyncs must be a valid pointer to an array of releaseCount valid VkDeviceMemory handles
VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pReleaseKeys-parameter
If releaseCount is not 0, pReleaseKeys must be a valid pointer to an array of releaseCount uint64_t values
VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-commonparent
Both of the elements of pAcquireSyncs, and the elements of pReleaseSyncs that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

If the pNext chain of VkSubmitInfo includes a VkProtectedSubmitInfo structure, then the structure indicates whether the batch is protected. The VkProtectedSubmitInfo structure is defined as:

typedef struct VkProtectedSubmitInfo {
    VkStructureType    sType;
    const void*        pNext;
    VkBool32           protectedSubmit;
} VkProtectedSubmitInfo;

protectedSubmit specifies whether the batch is protected. If protectedSubmit is VK_TRUE, the batch is protected. If protectedSubmit is VK_FALSE, the batch is unprotected. If the VkSubmitInfo::pNext chain does not include this structure, the batch is unprotected.

Valid Usage

VUID-VkProtectedSubmitInfo-protectedSubmit-01816
If the protected memory feature is not enabled, protectedSubmit must not be VK_TRUE.
VUID-VkProtectedSubmitInfo-protectedSubmit-01817
If protectedSubmit is VK_TRUE, then each element of the pCommandBuffers array must be a protected command buffer.
VUID-VkProtectedSubmitInfo-protectedSubmit-01818
If protectedSubmit is VK_FALSE, then each element of the pCommandBuffers array must be an unprotected command buffer.
VUID-VkProtectedSubmitInfo-pNext-01819
If the VkSubmitInfo::pNext chain does not include a VkProtectedSubmitInfo structure, then each element of the command buffer of the pCommandBuffers array must be an unprotected command buffer.

Valid Usage (Implicit)

VUID-VkProtectedSubmitInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO

If the pNext chain of VkSubmitInfo includes a VkDeviceGroupSubmitInfo structure, then that structure includes device indices and masks specifying which physical devices execute semaphore operations and command buffers.

The VkDeviceGroupSubmitInfo structure is defined as:

typedef struct VkDeviceGroupSubmitInfo {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           waitSemaphoreCount;
    const uint32_t*    pWaitSemaphoreDeviceIndices;
    uint32_t           commandBufferCount;
    const uint32_t*    pCommandBufferDeviceMasks;
    uint32_t           signalSemaphoreCount;
    const uint32_t*    pSignalSemaphoreDeviceIndices;
} VkDeviceGroupSubmitInfo;

or the equivalent

typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
waitSemaphoreCount is the number of elements in the pWaitSemaphoreDeviceIndices array.
pWaitSemaphoreDeviceIndices is a pointer to an array of waitSemaphoreCount device indices indicating which physical device executes the semaphore wait operation in the corresponding element of VkSubmitInfo::pWaitSemaphores.
commandBufferCount is the number of elements in the pCommandBufferDeviceMasks array.
pCommandBufferDeviceMasks is a pointer to an array of commandBufferCount device masks indicating which physical devices execute the command buffer in the corresponding element of VkSubmitInfo::pCommandBuffers. A physical device executes the command buffer if the corresponding bit is set in the mask.
signalSemaphoreCount is the number of elements in the pSignalSemaphoreDeviceIndices array.
pSignalSemaphoreDeviceIndices is a pointer to an array of signalSemaphoreCount device indices indicating which physical device executes the semaphore signal operation in the corresponding element of VkSubmitInfo::pSignalSemaphores.

If this structure is not present, semaphore operations and command buffers execute on device index zero.

Valid Usage

VUID-VkDeviceGroupSubmitInfo-waitSemaphoreCount-00082
waitSemaphoreCount must equal VkSubmitInfo::waitSemaphoreCount
VUID-VkDeviceGroupSubmitInfo-commandBufferCount-00083
commandBufferCount must equal VkSubmitInfo::commandBufferCount
VUID-VkDeviceGroupSubmitInfo-signalSemaphoreCount-00084
signalSemaphoreCount must equal VkSubmitInfo::signalSemaphoreCount
VUID-VkDeviceGroupSubmitInfo-pWaitSemaphoreDeviceIndices-00085
All elements of pWaitSemaphoreDeviceIndices and pSignalSemaphoreDeviceIndices must be valid device indices
VUID-VkDeviceGroupSubmitInfo-pCommandBufferDeviceMasks-00086
All elements of pCommandBufferDeviceMasks must be valid device masks

Valid Usage (Implicit)

VUID-VkDeviceGroupSubmitInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO
VUID-VkDeviceGroupSubmitInfo-pWaitSemaphoreDeviceIndices-parameter
If waitSemaphoreCount is not 0, pWaitSemaphoreDeviceIndices must be a valid pointer to an array of waitSemaphoreCount uint32_t values
VUID-VkDeviceGroupSubmitInfo-pCommandBufferDeviceMasks-parameter
If commandBufferCount is not 0, pCommandBufferDeviceMasks must be a valid pointer to an array of commandBufferCount uint32_t values
VUID-VkDeviceGroupSubmitInfo-pSignalSemaphoreDeviceIndices-parameter
If signalSemaphoreCount is not 0, pSignalSemaphoreDeviceIndices must be a valid pointer to an array of signalSemaphoreCount uint32_t values

If the pNext chain of VkSubmitInfo includes a VkPerformanceQuerySubmitInfoKHR structure, then the structure indicates which counter pass is active for the batch in that submit.

The VkPerformanceQuerySubmitInfoKHR structure is defined as:

typedef struct VkPerformanceQuerySubmitInfoKHR {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           counterPassIndex;
} VkPerformanceQuerySubmitInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
counterPassIndex specifies which counter pass index is active.

If the VkSubmitInfo::pNext chain does not include this structure, the batch defaults to use counter pass index 0.

Valid Usage

VUID-VkPerformanceQuerySubmitInfoKHR-counterPassIndex-03221
counterPassIndex must be less than the number of counter passes required by any queries within the batch. The required number of counter passes for a performance query is obtained by calling vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR

Valid Usage (Implicit)

VUID-VkPerformanceQuerySubmitInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR

5.6. Queue Forward Progress

When using binary semaphores, the application must ensure that command buffer submissions will be able to complete without any subsequent operations by the application on any queue. After any call to vkQueueSubmit (or other queue operation), for every queued wait on a semaphore created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY there must be a prior signal of that semaphore that will not be consumed by a different wait on the semaphore.

When using timeline semaphores, wait-before-signal behavior is well-defined and applications can submit work via vkQueueSubmit which defines a timeline semaphore wait operation before submitting a corresponding semaphore signal operation. For each timeline semaphore wait operation defined by a call to vkQueueSubmit, the application must ensure that a corresponding semaphore signal operation is executed before forward progress can be made.

Command buffers in the submission can include vkCmdWaitEvents commands that wait on events that will not be signaled by earlier commands in the queue. Such events must be signaled by the application using vkSetEvent, and the vkCmdWaitEvents commands that wait upon them must not be inside a render pass instance. The event must be set before the vkCmdWaitEvents command is executed.

Note

Implementations may have some tolerance for waiting on events to be set, but this is defined outside of the scope of Vulkan.

5.7. Secondary Command Buffer Execution

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 the command:

void vkCmdExecuteCommands(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    commandBufferCount,
    const VkCommandBuffer*                      pCommandBuffers);

commandBuffer is a handle to a primary command buffer that the secondary command buffers are executed in.
commandBufferCount is the length of the pCommandBuffers array.
pCommandBuffers is a pointer to an array of commandBufferCount secondary command buffer handles, which are recorded to execute in the primary command buffer in the order they are listed in the array.

If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, and it was recorded into any other primary command buffer which is currently in the executable or recording state, that primary command buffer becomes invalid.

Valid Usage

VUID-vkCmdExecuteCommands-pCommandBuffers-00088
Each element of pCommandBuffers must have been allocated with a level of VK_COMMAND_BUFFER_LEVEL_SECONDARY
VUID-vkCmdExecuteCommands-pCommandBuffers-00089
Each element of pCommandBuffers must be in the pending or executable state
VUID-vkCmdExecuteCommands-pCommandBuffers-00091
If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not be in the pending state
VUID-vkCmdExecuteCommands-pCommandBuffers-00092
If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not have already been recorded to commandBuffer
VUID-vkCmdExecuteCommands-pCommandBuffers-00093
If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not appear more than once in pCommandBuffers
VUID-vkCmdExecuteCommands-pCommandBuffers-00094
Each element of pCommandBuffers must have been allocated from a VkCommandPool that was created for the same queue family as the VkCommandPool from which commandBuffer was allocated
VUID-vkCmdExecuteCommands-contents-00095
If vkCmdExecuteCommands is being called within a render pass instance, that render pass instance must have been begun with the contents parameter of vkCmdBeginRenderPass set to VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
VUID-vkCmdExecuteCommands-pCommandBuffers-00096
If vkCmdExecuteCommands is being called within a render pass instance, each element of pCommandBuffers must have been recorded with the VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT
VUID-vkCmdExecuteCommands-pCommandBuffers-00097
If vkCmdExecuteCommands is being called within a render pass instance, each 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
VUID-vkCmdExecuteCommands-pInheritanceInfo-00098
If vkCmdExecuteCommands is being called within a render pass instance, the render passes specified in the pBeginInfo->pInheritanceInfo->renderPass members of the vkBeginCommandBuffer commands used to begin recording each element of pCommandBuffers must be compatible with the current render pass
VUID-vkCmdExecuteCommands-pCommandBuffers-00099
If vkCmdExecuteCommands is being called within a render pass instance, and any element of pCommandBuffers was recorded with VkCommandBufferInheritanceInfo::framebuffer not equal to VK_NULL_HANDLE, that VkFramebuffer must match the VkFramebuffer used in the current render pass instance
VUID-vkCmdExecuteCommands-pCommandBuffers-00100
If vkCmdExecuteCommands is not being called within a render pass instance, each element of pCommandBuffers must not have been recorded with the VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT
VUID-vkCmdExecuteCommands-commandBuffer-00101
If the inherited queries feature is not enabled, commandBuffer must not have any queries active
VUID-vkCmdExecuteCommands-commandBuffer-00102
If commandBuffer has a VK_QUERY_TYPE_OCCLUSION query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::occlusionQueryEnable set to VK_TRUE
VUID-vkCmdExecuteCommands-commandBuffer-00103
If commandBuffer has a VK_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
VUID-vkCmdExecuteCommands-commandBuffer-00104
If commandBuffer has a VK_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
VUID-vkCmdExecuteCommands-pCommandBuffers-00105
Each element of pCommandBuffers must not begin any query types that are active in commandBuffer
VUID-vkCmdExecuteCommands-commandBuffer-01820
If commandBuffer is a protected command buffer, then each element of pCommandBuffers must be a protected command buffer
VUID-vkCmdExecuteCommands-commandBuffer-01821
If commandBuffer is an unprotected command buffer, then each element of pCommandBuffers must be an unprotected command buffer
VUID-vkCmdExecuteCommands-None-02286
This command must not be recorded when transform feedback is active

Valid Usage (Implicit)

VUID-vkCmdExecuteCommands-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdExecuteCommands-pCommandBuffers-parameter
pCommandBuffers must be a valid pointer to an array of commandBufferCount valid VkCommandBuffer handles
VUID-vkCmdExecuteCommands-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdExecuteCommands-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations
VUID-vkCmdExecuteCommands-bufferlevel
commandBuffer must be a primary VkCommandBuffer
VUID-vkCmdExecuteCommands-commandBufferCount-arraylength
commandBufferCount must be greater than 0
VUID-vkCmdExecuteCommands-commonparent
Both of commandBuffer, and the elements of pCommandBuffers must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary	Both	Transfer Graphics Compute

Primary

Both

Transfer
Graphics
Compute

5.8. Command Buffer Device Mask

Each command buffer has a piece of state storing the current device mask of the command buffer. This mask controls which physical devices within the logical device all subsequent commands will execute on, including state-setting commands, action commands, and synchronization commands.

Scissor, exclusive scissor, and viewport state can be set to different values on each physical device (only when set as dynamic state), and each physical device will render using its local copy of the state. Other state is shared between physical devices, such that all physical devices use the most recently set values for the state. However, when recording an action command that uses a piece of state, the most recent command that set that state must have included all physical devices that execute the action command in its current device mask.

The command buffer’s device mask is orthogonal to the pCommandBufferDeviceMasks member of VkDeviceGroupSubmitInfo. Commands only execute on a physical device if the device index is set in both device masks.

If the pNext chain of VkCommandBufferBeginInfo includes a VkDeviceGroupCommandBufferBeginInfo structure, then that structure includes an initial device mask for the command buffer.

The VkDeviceGroupCommandBufferBeginInfo structure is defined as:

typedef struct VkDeviceGroupCommandBufferBeginInfo {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           deviceMask;
} VkDeviceGroupCommandBufferBeginInfo;

or the equivalent

typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
deviceMask is the initial value of the command buffer’s device mask.

The initial device mask also acts as an upper bound on the set of devices that can ever be in the device mask in the command buffer.

If this structure is not present, the initial value of a command buffer’s device mask is set to include all physical devices in the logical device when the command buffer begins recording.

Valid Usage

VUID-VkDeviceGroupCommandBufferBeginInfo-deviceMask-00106
deviceMask must be a valid device mask value
VUID-VkDeviceGroupCommandBufferBeginInfo-deviceMask-00107
deviceMask must not be zero

Valid Usage (Implicit)

VUID-VkDeviceGroupCommandBufferBeginInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO

To update the current device mask of a command buffer, call:

void vkCmdSetDeviceMask(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    deviceMask);

or the equivalent command

void vkCmdSetDeviceMaskKHR(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    deviceMask);

commandBuffer is command buffer whose current device mask is modified.
deviceMask is the new value of the current device mask.

deviceMask is used to filter out subsequent commands from executing on all physical devices whose bit indices are not set in the mask, except commands beginning a render pass instance, commands transitioning to the next subpass in the render pass instance, and commands ending a render pass instance, which always execute on the set of physical devices whose bit indices are included in the deviceMask member of the VkDeviceGroupRenderPassBeginInfo structure passed to the command beginning the corresponding render pass instance.

Valid Usage

VUID-vkCmdSetDeviceMask-deviceMask-00108
deviceMask must be a valid device mask value
VUID-vkCmdSetDeviceMask-deviceMask-00109
deviceMask must not be zero
VUID-vkCmdSetDeviceMask-deviceMask-00110
deviceMask must not include any set bits that were not in the VkDeviceGroupCommandBufferBeginInfo::deviceMask value when the command buffer began recording.
VUID-vkCmdSetDeviceMask-deviceMask-00111
If vkCmdSetDeviceMask is called inside a render pass instance, deviceMask must not include any set bits that were not in the VkDeviceGroupRenderPassBeginInfo::deviceMask value when the render pass instance began recording.

Valid Usage (Implicit)

VUID-vkCmdSetDeviceMask-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetDeviceMask-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetDeviceMask-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, compute, or transfer operations

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary Secondary	Both	Graphics Compute Transfer

Primary
Secondary

Both

Graphics
Compute
Transfer

6. Synchronization and Cache Control

Synchronization of access to resources is primarily the responsibility of the application in Vulkan. The order of execution of commands with respect to the host and other commands on the device has few implicit guarantees, and needs to be explicitly specified. Memory caches and other optimizations are also explicitly managed, requiring that the flow of data through the system is largely under application control.

Whilst some implicit guarantees exist between commands, five explicit synchronization mechanisms are exposed by Vulkan:

Fences: Fences can be used to communicate to the host that execution of some task on the device has completed.
Semaphores: Semaphores can be used to control resource access across multiple queues.
Events: Events provide a fine-grained synchronization primitive which can be signaled either within a command buffer or by the host, and can be waited upon within a command buffer or queried on the host.
Pipeline Barriers: Pipeline barriers also provide synchronization control within a command buffer, but at a single point, rather than with separate signal and wait operations.
Render Passes: Render passes provide a useful synchronization framework for most rendering tasks, built upon the concepts in this chapter. Many cases that would otherwise need an application to use other synchronization primitives can be expressed more efficiently as part of a render pass.

6.1. Execution and Memory Dependencies

An operation is an arbitrary amount of work to be executed on the host, a device, or an external entity such as a presentation engine. Synchronization commands introduce explicit execution dependencies, and memory dependencies between two sets of operations defined by the command’s two synchronization scopes.

The synchronization scopes define which other operations a synchronization command is able to create execution dependencies with. Any type of operation that is not in a synchronization command’s synchronization scopes will not be included in the resulting dependency. For example, for many synchronization commands, the synchronization scopes can be limited to just operations executing in specific pipeline stages, which allows other pipeline stages to be excluded from a dependency. Other scoping options are possible, depending on the particular command.

An execution dependency is a guarantee that for two sets of operations, the first set must happen-before the second set. If an operation happens-before another operation, then the first operation must complete before the second operation is initiated. More precisely:

Let A and B be separate sets of operations.
Let S be a synchronization command.
Let A_S and B_S be the synchronization scopes of S.
Let A' be the intersection of sets A and A_S.
Let B' be the intersection of sets B and B_S.
Submitting A, S and B for execution, in that order, will result in execution dependency E between A' and B'.
Execution dependency E guarantees that A' happens-before B'.

An execution dependency chain is a sequence of execution dependencies that form a happens-before relation between the first dependency’s A' and the final dependency’s B'. For each consecutive pair of execution dependencies, a chain exists if the intersection of B_S in the first dependency and A_S in the second dependency is not an empty set. The formation of a single execution dependency from an execution dependency chain can be described by substituting the following in the description of execution dependencies:

Let S be a set of synchronization commands that generate an execution dependency chain.
Let A_S be the first synchronization scope of the first command in S.
Let B_S be the second synchronization scope of the last command in S.

Execution dependencies alone are not sufficient to guarantee that values resulting from writes in one set of operations can be read from another set of operations.

Three additional types of operation are used to control memory access. Availability operations cause the values generated by specified memory write accesses to become available to a memory domain for future access. Any available value remains available until a subsequent write to the same memory location occurs (whether it is made available or not) or the memory is freed. Memory domain operations cause writes that are available to a source memory domain to become available to a destination memory domain (an example of this is making writes available to the host domain available to the device domain). Visibility operations cause values available to a memory domain to become visible to specified memory accesses.

Availability, visibility, memory domains, and memory domain operations are formally defined in the Availability and Visibility section of the Memory Model chapter. Which API operations perform each of these operations is defined in Availability, Visibility, and Domain Operations.

A memory dependency is an execution dependency which includes availability and visibility operations such that:

The first set of operations happens-before the availability operation.
The availability operation happens-before the visibility operation.
The visibility operation happens-before the second set of operations.

Once written values are made visible to a particular type of memory access, they can be read or written by that type of memory access. Most synchronization commands in Vulkan define a memory dependency.

The specific memory accesses that are made available and visible are defined by the access scopes of a memory dependency. Any type of access that is in a memory dependency’s first access scope and occurs in A' is made available. Any type of access that is in a memory dependency’s second access scope and occurs in B' has any available writes made visible to it. Any type of operation that is not in a synchronization command’s access scopes will not be included in the resulting dependency.

A memory dependency enforces availability and visibility of memory accesses and execution order between two sets of operations. Adding to the description of execution dependency chains:

Let a be the set of memory accesses performed by A'.
Let b be the set of memory accesses performed by B'.
Let a_S be the first access scope of the first command in S.
Let b_S be the second access scope of the last command in S.
Let a' be the intersection of sets a and a_S.
Let b' be the intersection of sets b and b_S.
Submitting A, S and B for execution, in that order, will result in a memory dependency m between A' and B'.
Memory dependency m guarantees that:
- Memory writes in a' are made available.
- Available memory writes, including those from a', are made visible to b'.

Note

Execution and memory dependencies are used to solve data hazards, i.e. to ensure that read and write operations occur in a well-defined order. Write-after-read hazards can be solved with just an execution dependency, but read-after-write and write-after-write hazards need appropriate memory dependencies to be included between them. If an application does not include dependencies to solve these hazards, the results and execution orders of memory accesses are undefined.

6.1.1. Image Layout Transitions

Image subresources can be transitioned from one layout to another as part of a memory dependency (e.g. by using an image memory barrier). When a layout transition is specified in a memory dependency, it happens-after the availability operations in the memory dependency, and happens-before the visibility operations. Image layout transitions may perform read and write accesses on all memory bound to the image subresource range, so applications must ensure that all memory writes have been made available before a layout transition is executed. Available memory is automatically made visible to a layout transition, and writes performed by a layout transition are automatically made available.

Layout transitions always apply to a particular image subresource range, and specify both an old layout and new layout. If the old layout does not match the new layout, a transition occurs. The old layout must match the current layout of the image subresource range, with one exception. The old layout can always be specified as VK_IMAGE_LAYOUT_UNDEFINED, though doing so invalidates the contents of the image subresource range.

As image layout transitions may perform read and write accesses on the memory bound to the image, if the image subresource affected by the layout transition is bound to peer memory for any device in the current device mask then the memory heap the bound memory comes from must support the VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT and VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT capabilities as returned by vkGetDeviceGroupPeerMemoryFeatures.

Note

Setting the old layout to VK_IMAGE_LAYOUT_UNDEFINED implies that the contents of the image subresource need not be preserved. Implementations may use this information to avoid performing expensive data transition operations.

Note

Applications must ensure that layout transitions happen-after all operations accessing the image with the old layout, and happen-before any operations that will access the image with the new layout. Layout transitions are potentially read/write operations, so not defining appropriate memory dependencies to guarantee this will result in a data race.

Image layout transitions interact with memory aliasing.

6.1.2. Pipeline Stages

The work performed by an action or synchronization command consists of multiple operations, which are performed as a sequence of logically independent steps known as pipeline stages. The exact pipeline stages executed depend on the particular command that is used, and current command buffer state when the command was recorded. Drawing commands, dispatching commands, copy commands, clear commands, and synchronization commands all execute in different sets of pipeline stages. Synchronization commands do not execute in a defined pipeline, but do execute VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT and VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT.

Note

Operations performed by synchronization commands (e.g. availability and visibility operations) are not executed by a defined pipeline stage. However other commands can still synchronize with them via the VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT and VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT pipeline stages.

Execution of operations across pipeline stages must adhere to implicit ordering guarantees, particularly including pipeline stage order. Otherwise, execution across pipeline stages may overlap or execute out of order with regards to other stages, unless otherwise enforced by an execution dependency.

Several of the synchronization commands include pipeline stage parameters, restricting the synchronization scopes for that command to just those stages. This allows fine grained control over the exact execution dependencies and accesses performed by action commands. Implementations should use these pipeline stages to avoid unnecessary stalls or cache flushing.

Bits which can be set, specifying pipeline stages, are:

typedef enum VkPipelineStageFlagBits {
    VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
    VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
    VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
    VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
    VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
    VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
    VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
    VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
    VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
    VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
    VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000,
    VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000,
    VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000,
    VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00400000,
    VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = 0x00200000,
    VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000,
    VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000,
    VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000,
    VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000,
    VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkPipelineStageFlagBits;

VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT specifies the stage of the pipeline where any commands are initially received by the queue.
VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT specifies the stage of the pipeline where Draw/DispatchIndirect data structures are consumed. This stage also includes reading commands written by vkCmdProcessCommandsNVX.
VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV specifies the task shader stage.
VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV specifies the mesh shader stage.
VK_PIPELINE_STAGE_VERTEX_INPUT_BIT specifies the stage of the pipeline where vertex and index buffers are consumed.
VK_PIPELINE_STAGE_VERTEX_SHADER_BIT specifies the vertex shader stage.
VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT specifies the tessellation control shader stage.
VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT specifies the tessellation evaluation shader stage.
VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT specifies the geometry shader stage.
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT specifies the fragment shader stage.
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT specifies the stage of the pipeline where early fragment tests (depth and stencil tests before fragment shading) are performed. This stage also includes subpass load operations for framebuffer attachments with a depth/stencil format.
VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT specifies the stage of the pipeline where late fragment tests (depth and stencil tests after fragment shading) are performed. This stage also includes subpass store operations for framebuffer attachments with a depth/stencil format.
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT specifies the stage of the pipeline after blending where the final color values are output from the pipeline. This stage also includes subpass load and store operations and multisample resolve operations for framebuffer attachments with a color or depth/stencil format.
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT specifies the execution of a compute shader.
VK_PIPELINE_STAGE_TRANSFER_BIT specifies the following commands:
- All copy commands, including vkCmdCopyQueryPoolResults
- vkCmdBlitImage
- vkCmdResolveImage
- All clear commands, with the exception of vkCmdClearAttachments
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT specifies the final stage in the pipeline where operations generated by all commands complete execution.
VK_PIPELINE_STAGE_HOST_BIT specifies a pseudo-stage indicating execution on the host of reads/writes of device memory. This stage is not invoked by any commands recorded in a command buffer.
VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV specifies the execution of the ray tracing shader stages.
VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV specifies the execution of vkCmdBuildAccelerationStructureNV, vkCmdCopyAccelerationStructureNV, and vkCmdWriteAccelerationStructuresPropertiesNV.
VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT specifies the execution of all graphics pipeline stages, and is equivalent to the logical OR of:
- VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
- VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT
- VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV
- VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV
- VK_PIPELINE_STAGE_VERTEX_INPUT_BIT
- VK_PIPELINE_STAGE_VERTEX_SHADER_BIT
- VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
- VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
- VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
- VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
- VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
- VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT
- VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
- VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT
- VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT
- VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT
- VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV
- VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT is equivalent to the logical OR of every other pipeline stage flag that is supported on the queue it is used with.
VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT specifies the stage of the pipeline where the predicate of conditional rendering is consumed.
VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT specifies the stage of the pipeline where vertex attribute output values are written to the transform feedback buffers.
VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX specifies the stage of the pipeline where device-side generation of commands via vkCmdProcessCommandsNVX is handled.
VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV specifies the stage of the pipeline where the shading rate image is read to determine the shading rate for portions of a rasterized primitive.
VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT specifies the stage of the pipeline where the fragment density map is read to generate the fragment areas.

Note

An execution dependency with only VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT in the destination stage mask will only prevent that stage from executing in subsequently submitted commands. As this stage does not perform any actual execution, this is not observable - in effect, it does not delay processing of subsequent commands. Similarly an execution dependency with only VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT in the source stage mask will effectively not wait for any prior commands to complete.

When defining a memory dependency, using only VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT or VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT would never make any accesses available and/or visible because these stages do not access memory.

VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT and VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT are useful for accomplishing layout transitions and queue ownership operations when the required execution dependency is satisfied by other means - for example, semaphore operations between queues.

typedef VkFlags VkPipelineStageFlags;

VkPipelineStageFlags is a bitmask type for setting a mask of zero or more VkPipelineStageFlagBits.

If a synchronization command includes a source stage mask, its first synchronization scope only includes execution of the pipeline stages specified in that mask, and its first access scope only includes memory access performed by pipeline stages specified in that mask. If a synchronization command includes a destination stage mask, its second synchronization scope only includes execution of the pipeline stages specified in that mask, and its second access scope only includes memory access performed by pipeline stages specified in that mask.

Note

Including a particular pipeline stage in the first synchronization scope of a command implicitly includes logically earlier pipeline stages in the synchronization scope. Similarly, the second synchronization scope includes logically later pipeline stages.

However, note that access scopes are not affected in this way - only the precise stages specified are considered part of each access scope.

Certain pipeline stages are only available on queues that support a particular set of operations. The following table lists, for each pipeline stage flag, which queue capability flag must be supported by the queue. When multiple flags are enumerated in the second column of the table, it means that the pipeline stage is supported on the queue if it supports any of the listed capability flags. For further details on queue capabilities see Physical Device Enumeration and Queues.

Table 3. Supported pipeline stage flags
Pipeline stage flag	Required queue capability flag
`VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT`	None required
`VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT`	`VK_QUEUE_GRAPHICS_BIT` or `VK_QUEUE_COMPUTE_BIT`
`VK_PIPELINE_STAGE_VERTEX_INPUT_BIT`	`VK_QUEUE_GRAPHICS_BIT`
`VK_PIPELINE_STAGE_VERTEX_SHADER_BIT`	`VK_QUEUE_GRAPHICS_BIT`
`VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT`	`VK_QUEUE_GRAPHICS_BIT`
`VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT`	`VK_QUEUE_GRAPHICS_BIT`
`VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT`	`VK_QUEUE_GRAPHICS_BIT`
`VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT`	`VK_QUEUE_GRAPHICS_BIT`
`VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT`	`VK_QUEUE_GRAPHICS_BIT`
`VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT`	`VK_QUEUE_GRAPHICS_BIT`
`VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT`	`VK_QUEUE_GRAPHICS_BIT`
`VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT`	`VK_QUEUE_COMPUTE_BIT`
`VK_PIPELINE_STAGE_TRANSFER_BIT`	`VK_QUEUE_GRAPHICS_BIT`, `VK_QUEUE_COMPUTE_BIT` or `VK_QUEUE_TRANSFER_BIT`
`VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT`	None required
`VK_PIPELINE_STAGE_HOST_BIT`	None required
`VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT`	`VK_QUEUE_GRAPHICS_BIT`
`VK_PIPELINE_STAGE_ALL_COMMANDS_BIT`	None required
`VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT`	`VK_QUEUE_GRAPHICS_BIT` or `VK_QUEUE_COMPUTE_BIT`
`VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT`	`VK_QUEUE_GRAPHICS_BIT`
`VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX`	`VK_QUEUE_GRAPHICS_BIT` or `VK_QUEUE_COMPUTE_BIT`
`VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV`	`VK_QUEUE_GRAPHICS_BIT`
`VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV`	`VK_QUEUE_GRAPHICS_BIT`
`VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV`	`VK_QUEUE_GRAPHICS_BIT`
`VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV`	`VK_QUEUE_COMPUTE_BIT`
`VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV`	`VK_QUEUE_COMPUTE_BIT`
`VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT`	`VK_QUEUE_GRAPHICS_BIT`

Pipeline stages that execute as a result of a command logically complete execution in a specific order, such that completion of a logically later pipeline stage must not happen-before completion of a logically earlier stage. This means that including any stage in the source stage mask for a particular synchronization command also implies that any logically earlier stages are included in A_S for that command.

Similarly, initiation of a logically earlier pipeline stage must not happen-after initiation of a logically later pipeline stage. Including any given stage in the destination stage mask for a particular synchronization command also implies that any logically later stages are included in B_S for that command.

Note

Implementations may not support synchronization at every pipeline stage for every synchronization operation. If a pipeline stage that an implementation does not support synchronization for appears in a source stage mask, it may substitute any logically later stage in its place for the first synchronization scope. If a pipeline stage that an implementation does not support synchronization for appears in a destination stage mask, it may substitute any logically earlier stage in its place for the second synchronization scope.

For example, if an implementation is unable to signal an event immediately after vertex shader execution is complete, it may instead signal the event after color attachment output has completed.

If an implementation makes such a substitution, it must not affect the semantics of execution or memory dependencies or image and buffer memory barriers.

The order and set of pipeline stages executed by a given command is determined by the command’s pipeline type, as described below:

For the graphics primitive shading pipeline, the following stages occur in this order:

VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT
VK_PIPELINE_STAGE_VERTEX_INPUT_BIT
VK_PIPELINE_STAGE_VERTEX_SHADER_BIT
VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT
VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT

For the graphics mesh shading pipeline, the following stages occur in this order:

VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT
VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV
VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV
VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT

For graphics pipeline commands executing in a render pass with a fragment density map attachment, the pipeline stage where the fragment density map read happens has no particular order relative to the other stages except that it happens before VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT.

VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT

For the compute pipeline, the following stages occur in this order:

VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT

The conditional rendering stage is formally part of both the graphics, and the compute pipeline. The pipeline stage where the predicate read happens has unspecified order relative to other stages of these pipelines:

VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT

For the transfer pipeline, the following stages occur in this order:

VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
VK_PIPELINE_STAGE_TRANSFER_BIT
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT

For host operations, only one pipeline stage occurs, so no order is guaranteed:

VK_PIPELINE_STAGE_HOST_BIT

For the command processing pipeline, the following stages occur in this order:

VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT

For the ray tracing shader pipeline, only one pipeline stage occurs, so no order is guaranteed:

VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV

For ray tracing acceleration structure operations, only one pipeline stage occurs, so no order is guaranteed:

VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV

6.1.3. Access Types

Memory in Vulkan can be accessed from within shader invocations and via some fixed-function stages of the pipeline. The access type is a function of the descriptor type used, or how a fixed-function stage accesses memory. Each access type corresponds to a bit flag in VkAccessFlagBits.

Some synchronization commands take sets of access types as parameters to define the access scopes of a memory dependency. If a synchronization command includes a source access mask, its first access scope only includes accesses via the access types specified in that mask. Similarly, if a synchronization command includes a destination access mask, its second access scope only includes accesses via the access types specified in that mask.

Access types that can be set in an access mask include:

typedef enum VkAccessFlagBits {
    VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
    VK_ACCESS_INDEX_READ_BIT = 0x00000002,
    VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
    VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
    VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
    VK_ACCESS_SHADER_READ_BIT = 0x00000020,
    VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
    VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
    VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
    VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
    VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
    VK_ACCESS_HOST_READ_BIT = 0x00002000,
    VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
    VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
    VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
    VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000,
    VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000,
    VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000,
    VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000,
    VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000,
    VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000,
    VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000,
    VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000,
    VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000,
    VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000,
    VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000,
    VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkAccessFlagBits;

VK_ACCESS_INDIRECT_COMMAND_READ_BIT specifies read access to indirect command data read as part of an indirect drawing or dispatch command.
VK_ACCESS_INDEX_READ_BIT specifies read access to an index buffer as part of an indexed drawing command, bound by vkCmdBindIndexBuffer.
VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT specifies read access to a vertex buffer as part of a drawing command, bound by vkCmdBindVertexBuffers.
VK_ACCESS_UNIFORM_READ_BIT specifies read access to a uniform buffer.
VK_ACCESS_INPUT_ATTACHMENT_READ_BIT specifies read access to an input attachment within a render pass during fragment shading.
VK_ACCESS_SHADER_READ_BIT specifies read access to a storage buffer, physical storage buffer, uniform texel buffer, storage texel buffer, sampled image, or storage image.
VK_ACCESS_SHADER_WRITE_BIT specifies write access to a storage buffer, physical storage buffer, storage texel buffer, or storage image.
VK_ACCESS_COLOR_ATTACHMENT_READ_BIT specifies read access to a color attachment, such as via blending, logic operations, or via certain subpass load operations. It does not include advanced blend operations.
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT specifies write access to a color, resolve, or depth/stencil resolve attachment during a render pass or via certain subpass load and store operations.
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT specifies read access to a depth/stencil attachment, via depth or stencil operations or via certain subpass load operations.
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT specifies write access to a depth/stencil attachment, via depth or stencil operations or via certain subpass load and store operations.
VK_ACCESS_TRANSFER_READ_BIT specifies read access to an image or buffer in a copy operation.
VK_ACCESS_TRANSFER_WRITE_BIT specifies write access to an image or buffer in a clear or copy operation.
VK_ACCESS_HOST_READ_BIT specifies read access by a host operation. Accesses of this type are not performed through a resource, but directly on memory.
VK_ACCESS_HOST_WRITE_BIT specifies write access by a host operation. Accesses of this type are not performed through a resource, but directly on memory.
VK_ACCESS_MEMORY_READ_BIT specifies all read accesses. It is always valid in any access mask, and is treated as equivalent to setting all READ access flags that are valid where it is used.
VK_ACCESS_MEMORY_WRITE_BIT specifies all write accesses. It is always valid in any access mask, and is treated as equivalent to setting all WRITE access flags that are valid where it is used.
VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT specifies read access to a predicate as part of conditional rendering.
VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT specifies write access to a transform feedback buffer made when transform feedback is active.
VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT specifies read access to a transform feedback counter buffer which is read when vkCmdBeginTransformFeedbackEXT executes.
VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT specifies write access to a transform feedback counter buffer which is written when vkCmdEndTransformFeedbackEXT executes.
VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX specifies reads from VkBuffer inputs to vkCmdProcessCommandsNVX.
VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX specifies writes to the target command buffer in vkCmdProcessCommandsNVX.
VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT is similar to VK_ACCESS_COLOR_ATTACHMENT_READ_BIT, but also includes advanced blend operations.
VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV specifies read access to a shading rate image as part of a drawing command, as bound by vkCmdBindShadingRateImageNV.
VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV specifies read access to an acceleration structure as part of a trace or build command.
VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV specifies write access to an acceleration structure as part of a build command.
VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT specifies read access to a fragment density map attachment during dynamic fragment density map operations

Certain access types are only performed by a subset of pipeline stages. Any synchronization command that takes both stage masks and access masks uses both to define the access scopes - only the specified access types performed by the specified stages are included in the access scope. An application must not specify an access flag in a synchronization command if it does not include a pipeline stage in the corresponding stage mask that is able to perform accesses of that type. The following table lists, for each access flag, which pipeline stages can perform that type of access.

Table 4. Supported access types
Access flag	Supported pipeline stages
`VK_ACCESS_INDIRECT_COMMAND_READ_BIT`	`VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT`
`VK_ACCESS_INDEX_READ_BIT`	`VK_PIPELINE_STAGE_VERTEX_INPUT_BIT`
`VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT`	`VK_PIPELINE_STAGE_VERTEX_INPUT_BIT`
`VK_ACCESS_UNIFORM_READ_BIT`	`VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV`, `VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV`, `VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV`, `VK_PIPELINE_STAGE_VERTEX_SHADER_BIT`, `VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT`, `VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT`, `VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT`, `VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT`, or `VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT`
`VK_ACCESS_SHADER_READ_BIT`	`VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV`, `VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV`, `VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV`, `VK_PIPELINE_STAGE_VERTEX_SHADER_BIT`, `VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT`, `VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT`, `VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT`, `VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT`, or `VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT`
`VK_ACCESS_SHADER_WRITE_BIT`	`VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV`, `VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV`, `VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV`, `VK_PIPELINE_STAGE_VERTEX_SHADER_BIT`, `VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT`, `VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT`, `VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT`, `VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT`, or `VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT`
`VK_ACCESS_INPUT_ATTACHMENT_READ_BIT`	`VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT`
`VK_ACCESS_COLOR_ATTACHMENT_READ_BIT`	`VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT`
`VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT`	`VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT`
`VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT`	`VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT`, or `VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT`
`VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT`	`VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT`, or `VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT`
`VK_ACCESS_TRANSFER_READ_BIT`	`VK_PIPELINE_STAGE_TRANSFER_BIT`
`VK_ACCESS_TRANSFER_WRITE_BIT`	`VK_PIPELINE_STAGE_TRANSFER_BIT`
`VK_ACCESS_HOST_READ_BIT`	`VK_PIPELINE_STAGE_HOST_BIT`
`VK_ACCESS_HOST_WRITE_BIT`	`VK_PIPELINE_STAGE_HOST_BIT`
`VK_ACCESS_MEMORY_READ_BIT`	Any
`VK_ACCESS_MEMORY_WRITE_BIT`	Any
`VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT`	`VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT`
`VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX`	`VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX`
`VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX`	`VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX`
`VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT`	`VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT`
`VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV`	`VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV`
`VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT`	`VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT`
`VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT`	`VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT`
`VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT`	`VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT`
`VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV`	`VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV`, or `VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV`
`VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV`	`VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV`
`VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT`	`VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT`

If a memory object does not have the VK_MEMORY_PROPERTY_HOST_COHERENT_BIT property, then vkFlushMappedMemoryRanges must be called in order to guarantee that writes to the memory object from the host are made available to the host domain, where they can be further made available to the device domain via a domain operation. Similarly, vkInvalidateMappedMemoryRanges must be called to guarantee that writes which are available to the host domain are made visible to host operations.

If the memory object does have the VK_MEMORY_PROPERTY_HOST_COHERENT_BIT property flag, writes to the memory object from the host are automatically made available to the host domain. Similarly, writes made available to the host domain are automatically made visible to the host.

Note

The vkQueueSubmit command automatically performs a domain operation from host to device for all writes performed before the command executes, so in most cases an explicit memory barrier is not needed for this case. In the few circumstances where a submit does not occur between the host write and the device read access, writes can be made available by using an explicit memory barrier.

typedef VkFlags VkAccessFlags;

VkAccessFlags is a bitmask type for setting a mask of zero or more VkAccessFlagBits.

6.1.4. Framebuffer Region Dependencies

Pipeline stages that operate on, or with respect to, the framebuffer are collectively the framebuffer-space pipeline stages. These stages are:

VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT

For these pipeline stages, an execution or memory dependency from the first set of operations to the second set can either be a single framebuffer-global dependency, or split into multiple framebuffer-local dependencies. A dependency with non-framebuffer-space pipeline stages is neither framebuffer-global nor framebuffer-local.

A framebuffer region is a set of sample (x, y, layer, sample) coordinates that is a subset of the entire framebuffer.

Both synchronization scopes of a framebuffer-local dependency include only the operations performed within corresponding framebuffer regions (as defined below). No ordering guarantees are made between different framebuffer regions for a framebuffer-local dependency.

Both synchronization scopes of a framebuffer-global dependency include operations on all framebuffer-regions.

If the first synchronization scope includes operations on pixels/fragments with N samples and the second synchronization scope includes operations on pixels/fragments with M samples, where N does not equal M, then a framebuffer region containing all samples at a given (x, y, layer) coordinate in the first synchronization scope corresponds to a region containing all samples at the same coordinate in the second synchronization scope. In other words, it is a pixel granularity dependency. If N equals M, then a framebuffer region containing a single (x, y, layer, sample) coordinate in the first synchronization scope corresponds to a region containing the same sample at the same coordinate in the second synchronization scope. In other words, it is a sample granularity dependency.

Note

Since fragment invocations are not specified to run in any particular groupings, the size of a framebuffer region is implementation-dependent, not known to the application, and must be assumed to be no larger than specified above.

Note

Practically, the pixel vs sample granularity dependency means that if an input attachment has a different number of samples than the pipeline’s rasterizationSamples, then a fragment can access any sample in the input attachment’s pixel even if it only uses framebuffer-local dependencies. If the input attachment has the same number of samples, then the fragment can only access the covered samples in its input SampleMask (i.e. the fragment operations happen-after a framebuffer-local dependency for each sample the fragment covers). To access samples that are not covered, a framebuffer-global dependency is required.

If a synchronization command includes a dependencyFlags parameter, and specifies the VK_DEPENDENCY_BY_REGION_BIT flag, then it defines framebuffer-local dependencies for the framebuffer-space pipeline stages in that synchronization command, for all framebuffer regions. If no dependencyFlags parameter is included, or the VK_DEPENDENCY_BY_REGION_BIT flag is not specified, then a framebuffer-global dependency is specified for those stages. The VK_DEPENDENCY_BY_REGION_BIT flag does not affect the dependencies between non-framebuffer-space pipeline stages, nor does it affect the dependencies between framebuffer-space and non-framebuffer-space pipeline stages.

Note

Framebuffer-local dependencies are more optimal for most architectures; particularly tile-based architectures - which can keep framebuffer-regions entirely in on-chip registers and thus avoid external bandwidth across such a dependency. Including a framebuffer-global dependency in your rendering will usually force all implementations to flush data to memory, or to a higher level cache, breaking any potential locality optimizations.

6.1.5. View-Local Dependencies

In a render pass instance that has multiview enabled, dependencies can be either view-local or view-global.

A view-local dependency only includes operations from a single source view from the source subpass in the first synchronization scope, and only includes operations from a single destination view from the destination subpass in the second synchronization scope. A view-global dependency includes all views in the view mask of the source and destination subpasses in the corresponding synchronization scopes.

If a synchronization command includes a dependencyFlags parameter and specifies the VK_DEPENDENCY_VIEW_LOCAL_BIT flag, then it defines view-local dependencies for that synchronization command, for all views. If no dependencyFlags parameter is included or the VK_DEPENDENCY_VIEW_LOCAL_BIT flag is not specified, then a view-global dependency is specified.

6.1.6. Device-Local Dependencies

Dependencies can be either device-local or non-device-local. A device-local dependency acts as multiple separate dependencies, one for each physical device that executes the synchronization command, where each dependency only includes operations from that physical device in both synchronization scopes. A non-device-local dependency is a single dependency where both synchronization scopes include operations from all physical devices that participate in the synchronization command. For subpass dependencies, all physical devices in the VkDeviceGroupRenderPassBeginInfo::deviceMask participate in the dependency, and for pipeline barriers all physical devices that are set in the command buffer’s current device mask participate in the dependency.

If a synchronization command includes a dependencyFlags parameter and specifies the VK_DEPENDENCY_DEVICE_GROUP_BIT flag, then it defines a non-device-local dependency for that synchronization command. If no dependencyFlags parameter is included or the VK_DEPENDENCY_DEVICE_GROUP_BIT flag is not specified, then it defines device-local dependencies for that synchronization command, for all participating physical devices.

Semaphore and event dependencies are device-local and only execute on the one physical device that performs the dependency.

6.2. Implicit Synchronization Guarantees

A small number of implicit ordering guarantees are provided by Vulkan, ensuring that the order in which commands are submitted is meaningful, and avoiding unnecessary complexity in common operations.

Submission order is a fundamental ordering in Vulkan, giving meaning to the order in which action and synchronization commands are recorded and submitted to a single queue. Explicit and implicit ordering guarantees between commands in Vulkan all work on the premise that this ordering is meaningful. This order does not itself define any execution or memory dependencies; synchronization commands and other orderings within the API use this ordering to define their scopes.

Submission order for any given set of commands is based on the order in which they were recorded to command buffers and then submitted. This order is determined as follows:

The initial order is determined by the order in which vkQueueSubmit commands are executed on the host, for a single queue, from first to last.
The order in which VkSubmitInfo structures are specified in the pSubmits parameter of vkQueueSubmit, from lowest index to highest.
The order in which command buffers are specified in the pCommandBuffers member of VkSubmitInfo, from lowest index to highest.
The order in which commands were recorded to a command buffer on the host, from first to last:
- For commands recorded outside a render pass, this includes all other commands recorded outside a render pass, including vkCmdBeginRenderPass and vkCmdEndRenderPass commands; it does not directly include commands inside a render pass.
- For commands recorded inside a render pass, this includes all other commands recorded inside the same subpass, including the vkCmdBeginRenderPass and vkCmdEndRenderPass commands that delimit the same render pass instance; it does not include commands recorded to other subpasses.

Action and synchronization commands recorded to a command buffer execute the VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT pipeline stage in submission order - forming an implicit execution dependency between this stage in each command.

State commands do not execute any operations on the device, instead they set the state of the command buffer when they execute on the host, in the order that they are recorded. Action commands consume the current state of the command buffer when they are recorded, and will execute state changes on the device as required to match the recorded state.

Query commands, the order of primitives passing through the graphics pipeline and image layout transitions as part of an image memory barrier provide additional guarantees based on submission order.

Execution of pipeline stages within a given command also has a loose ordering, dependent only on a single command.

Signal operation order is a fundamental ordering in Vulkan, giving meaning to the order in which semaphore and fence signal operations occur when submitted to a single queue. The signal operation order for queue operations is determined as follows:

The initial order is determined by the order in which vkQueueSubmit commands are executed on the host, for a single queue, from first to last.
The order in which VkSubmitInfo structures are specified in the pSubmits parameter of vkQueueSubmit, from lowest index to highest.
The fence signal operation defined by the fence parameter of a vkQueueSubmit or vkQueueBindSparse command is ordered after all semaphore signal operations defined by that command.

Semaphore signal operations defined by a single VkSubmitInfo or VkBindSparseInfo structure are unordered with respect to other semaphore signal operations defined within the same VkSubmitInfo or VkBindSparseInfo structure.

The vkSignalSemaphore command does not execute on a queue but instead performs the signal operation from the host. The semaphore signal operation defined by executing a vkSignalSemaphore command happens-after the vkSignalSemaphore command is invoked and happens-before the command returns.

Note

When signaling timeline semaphores, it is the responsibility of the client to ensure that they are ordered such that the semaphore value is strictly increasing. Because the first synchronization scope for a semaphore signal operation contains all semaphore signal operations which occur earlier in submission order, all semaphore signal operations contained in any given batch are guaranteed to happen-after all semaphore signal operations contained in any previous batches. However, no ordering guarantee is provided between the semaphore signal operations defined within a single batch. This, combined with the requirement that timeline semaphore values strictly increase, means that it is invalid to signal the same timeline semaphore twice within a single batch.

If a client wishes to ensure that some semaphore signal operation happens-after some other semaphore signal operation, it can submit a separate batch containing only semaphore signal operations, which will happen-after the semaphore signal operations in any earlier batches.

When signaling a semaphore from the host, the only ordering guarantee is that the signal operation happens-after when vkSignalSemaphore is called and happens-before it returns. Therefore, it is invalid to call vkSignalSemaphore while there are any outstanding signal operations on that semaphore from any queue submissions unless those queue submissions have some dependency which ensures that they happen-after the host signal operation. One example of this would be if the pending signal operation is, itself, waiting on the same semaphore at a lower value and the call to vkSignalSemaphore signals that lower value. Furthermore, if there are two or more processes or threads signaling the same timeline semaphore from the host, the client must ensure that the vkSignalSemaphore with the lower semaphore value returns before vkSignalSemaphore is called with the higher value.

6.3. Fences

Fences are a synchronization primitive that can be used to insert a dependency from a queue to the host. Fences have two states - signaled and unsignaled. A fence can be signaled as part of the execution of a queue submission command. Fences can be unsignaled on the host with vkResetFences. Fences can be waited on by the host with the vkWaitForFences command, and the current state can be queried with vkGetFenceStatus.

As with most objects in Vulkan, fences are an interface to internal data which is typically opaque to applications. This internal data is referred to as a fence’s payload.

However, in order to enable communication with agents outside of the current device, it is necessary to be able to export that payload to a commonly understood format, and subsequently import from that format as well.

The internal data of a fence may include a reference to any resources and pending work associated with signal or unsignal operations performed on that fence object. Mechanisms to import and export that internal data to and from fences are provided below. These mechanisms indirectly enable applications to share fence state between two or more fences and other synchronization primitives across process and API boundaries.

Fences are represented by VkFence handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)

To create a fence, call:

VkResult vkCreateFence(
    VkDevice                                    device,
    const VkFenceCreateInfo*                    pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkFence*                                    pFence);

device is the logical device that creates the fence.
pCreateInfo is a pointer to a VkFenceCreateInfo structure containing information about how the fence is to be created.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pFence is a pointer to a handle in which the resulting fence object is returned.

Valid Usage (Implicit)

VUID-vkCreateFence-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateFence-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkFenceCreateInfo structure
VUID-vkCreateFence-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateFence-pFence-parameter
pFence must be a valid pointer to a VkFence handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkFenceCreateInfo structure is defined as:

typedef struct VkFenceCreateInfo {
    VkStructureType       sType;
    const void*           pNext;
    VkFenceCreateFlags    flags;
} VkFenceCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkFenceCreateFlagBits specifying the initial state and behavior of the fence.

Valid Usage (Implicit)

VUID-VkFenceCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
VUID-VkFenceCreateInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExportFenceCreateInfo or VkExportFenceWin32HandleInfoKHR
VUID-VkFenceCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkFenceCreateInfo-flags-parameter
flags must be a valid combination of VkFenceCreateFlagBits values

typedef enum VkFenceCreateFlagBits {
    VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
    VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkFenceCreateFlagBits;

VK_FENCE_CREATE_SIGNALED_BIT specifies that the fence object is created in the signaled state. Otherwise, it is created in the unsignaled state.

typedef VkFlags VkFenceCreateFlags;

VkFenceCreateFlags is a bitmask type for setting a mask of zero or more VkFenceCreateFlagBits.

To create a fence whose payload can be exported to external handles, add a VkExportFenceCreateInfo structure to the pNext chain of the VkFenceCreateInfo structure. The VkExportFenceCreateInfo structure is defined as:

typedef struct VkExportFenceCreateInfo {
    VkStructureType                   sType;
    const void*                       pNext;
    VkExternalFenceHandleTypeFlags    handleTypes;
} VkExportFenceCreateInfo;

or the equivalent

typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
handleTypes is a bitmask of VkExternalFenceHandleTypeFlagBits specifying one or more fence handle types the application can export from the resulting fence. The application can request multiple handle types for the same fence.

Valid Usage

VUID-VkExportFenceCreateInfo-handleTypes-01446
The bits in handleTypes must be supported and compatible, as reported by VkExternalFenceProperties.

Valid Usage (Implicit)

VUID-VkExportFenceCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO
VUID-VkExportFenceCreateInfo-handleTypes-parameter
handleTypes must be a valid combination of VkExternalFenceHandleTypeFlagBits values

To specify additional attributes of NT handles exported from a fence, add a VkExportFenceWin32HandleInfoKHR structure to the pNext chain of the VkFenceCreateInfo structure. The VkExportFenceWin32HandleInfoKHR structure is defined as:

typedef struct VkExportFenceWin32HandleInfoKHR {
    VkStructureType               sType;
    const void*                   pNext;
    const SECURITY_ATTRIBUTES*    pAttributes;
    DWORD                         dwAccess;
    LPCWSTR                       name;
} VkExportFenceWin32HandleInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
pAttributes is a pointer to a Windows SECURITY_ATTRIBUTES structure specifying security attributes of the handle.
dwAccess is a DWORD specifying access rights of the handle.
name is a null-terminated UTF-16 string to associate with the underlying synchronization primitive referenced by NT handles exported from the created fence.

If this structure is not present, or if pAttributes is set to NULL, default security descriptor values will be used, and child processes created by the application will not inherit the handle, as described in the MSDN documentation for “Synchronization Object Security and Access Rights”¹. Further, if the structure is not present, the access rights will be

DXGI_SHARED_RESOURCE_READ | DXGI_SHARED_RESOURCE_WRITE

for handles of the following types:

VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT

1: https://docs.microsoft.com/en-us/windows/win32/sync/synchronization-object-security-and-access-rights

Valid Usage

VUID-VkExportFenceWin32HandleInfoKHR-handleTypes-01447
If VkExportFenceCreateInfo::handleTypes does not include VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, a VkExportFenceWin32HandleInfoKHR structure must not be included in the pNext chain of VkFenceCreateInfo.

Valid Usage (Implicit)

VUID-VkExportFenceWin32HandleInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR
VUID-VkExportFenceWin32HandleInfoKHR-pAttributes-parameter
If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value

To export a Windows handle representing the state of a fence, call:

VkResult vkGetFenceWin32HandleKHR(
    VkDevice                                    device,
    const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
    HANDLE*                                     pHandle);

device is the logical device that created the fence being exported.
pGetWin32HandleInfo is a pointer to a VkFenceGetWin32HandleInfoKHR structure containing parameters of the export operation.
pHandle will return the Windows handle representing the fence state.

For handle types defined as NT handles, the handles returned by vkGetFenceWin32HandleKHR are owned by the application. To avoid leaking resources, the application must release ownership of them using the CloseHandle system call when they are no longer needed.

Exporting a Windows handle from a fence may have side effects depending on the transference of the specified handle type, as described in Importing Fence Payloads.

Valid Usage (Implicit)

VUID-vkGetFenceWin32HandleKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkGetFenceWin32HandleKHR-pGetWin32HandleInfo-parameter
pGetWin32HandleInfo must be a valid pointer to a valid VkFenceGetWin32HandleInfoKHR structure
VUID-vkGetFenceWin32HandleKHR-pHandle-parameter
pHandle must be a valid pointer to a HANDLE value

Return Codes

VK_SUCCESS

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

The VkFenceGetWin32HandleInfoKHR structure is defined as:

typedef struct VkFenceGetWin32HandleInfoKHR {
    VkStructureType                      sType;
    const void*                          pNext;
    VkFence                              fence;
    VkExternalFenceHandleTypeFlagBits    handleType;
} VkFenceGetWin32HandleInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
fence is the fence from which state will be exported.
handleType is the type of handle requested.

The properties of the handle returned depend on the value of handleType. See VkExternalFenceHandleTypeFlagBits for a description of the properties of the defined external fence handle types.

Valid Usage

VUID-VkFenceGetWin32HandleInfoKHR-handleType-01448
handleType must have been included in VkExportFenceCreateInfo::handleTypes when the fence’s current payload was created.
VUID-VkFenceGetWin32HandleInfoKHR-handleType-01449
If handleType is defined as an NT handle, vkGetFenceWin32HandleKHR must be called no more than once for each valid unique combination of fence and handleType.
VUID-VkFenceGetWin32HandleInfoKHR-fence-01450
fence must not currently have its payload replaced by an imported payload as described below in Importing Fence Payloads unless that imported payload’s handle type was included in VkExternalFenceProperties::exportFromImportedHandleTypes for handleType.
VUID-VkFenceGetWin32HandleInfoKHR-handleType-01451
If handleType refers to a handle type with copy payload transference semantics, fence must be signaled, or have an associated fence signal operation pending execution.
VUID-VkFenceGetWin32HandleInfoKHR-handleType-01452
handleType must be defined as an NT handle or a global share handle.

Valid Usage (Implicit)

VUID-VkFenceGetWin32HandleInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR
VUID-VkFenceGetWin32HandleInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkFenceGetWin32HandleInfoKHR-fence-parameter
fence must be a valid VkFence handle
VUID-VkFenceGetWin32HandleInfoKHR-handleType-parameter
handleType must be a valid VkExternalFenceHandleTypeFlagBits value

To export a POSIX file descriptor representing the payload of a fence, call:

VkResult vkGetFenceFdKHR(
    VkDevice                                    device,
    const VkFenceGetFdInfoKHR*                  pGetFdInfo,
    int*                                        pFd);

device is the logical device that created the fence being exported.
pGetFdInfo is a pointer to a VkFenceGetFdInfoKHR structure containing parameters of the export operation.
pFd will return the file descriptor representing the fence payload.

Each call to vkGetFenceFdKHR must create a new file descriptor and transfer ownership of it to the application. To avoid leaking resources, the application must release ownership of the file descriptor when it is no longer needed.

Note

Ownership can be released in many ways. For example, the application can call close() on the file descriptor, or transfer ownership back to Vulkan by using the file descriptor to import a fence payload.

If pGetFdInfo->handleType is VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT and the fence is signaled at the time vkGetFenceFdKHR is called, pFd may return the value -1 instead of a valid file descriptor.

Where supported by the operating system, the implementation must set the file descriptor to be closed automatically when an execve system call is made.

Exporting a file descriptor from a fence may have side effects depending on the transference of the specified handle type, as described in Importing Fence State.

Valid Usage (Implicit)

VUID-vkGetFenceFdKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkGetFenceFdKHR-pGetFdInfo-parameter
pGetFdInfo must be a valid pointer to a valid VkFenceGetFdInfoKHR structure
VUID-vkGetFenceFdKHR-pFd-parameter
pFd must be a valid pointer to an int value

Return Codes

VK_SUCCESS

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

The VkFenceGetFdInfoKHR structure is defined as:

typedef struct VkFenceGetFdInfoKHR {
    VkStructureType                      sType;
    const void*                          pNext;
    VkFence                              fence;
    VkExternalFenceHandleTypeFlagBits    handleType;
} VkFenceGetFdInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
fence is the fence from which state will be exported.
handleType is the type of handle requested.

The properties of the file descriptor returned depend on the value of handleType. See VkExternalFenceHandleTypeFlagBits for a description of the properties of the defined external fence handle types.

Valid Usage

VUID-VkFenceGetFdInfoKHR-handleType-01453
handleType must have been included in VkExportFenceCreateInfo::handleTypes when fence’s current payload was created.
VUID-VkFenceGetFdInfoKHR-handleType-01454
If handleType refers to a handle type with copy payload transference semantics, fence must be signaled, or have an associated fence signal operation pending execution.
VUID-VkFenceGetFdInfoKHR-fence-01455
fence must not currently have its payload replaced by an imported payload as described below in Importing Fence Payloads unless that imported payload’s handle type was included in VkExternalFenceProperties::exportFromImportedHandleTypes for handleType.
VUID-VkFenceGetFdInfoKHR-handleType-01456
handleType must be defined as a POSIX file descriptor handle.

Valid Usage (Implicit)

VUID-VkFenceGetFdInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR
VUID-VkFenceGetFdInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkFenceGetFdInfoKHR-fence-parameter
fence must be a valid VkFence handle
VUID-VkFenceGetFdInfoKHR-handleType-parameter
handleType must be a valid VkExternalFenceHandleTypeFlagBits value

To destroy a fence, call:

void vkDestroyFence(
    VkDevice                                    device,
    VkFence                                     fence,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the fence.
fence is the handle of the fence to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyFence-fence-01120
All queue submission commands that refer to fence must have completed execution
VUID-vkDestroyFence-fence-01121
If VkAllocationCallbacks were provided when fence was created, a compatible set of callbacks must be provided here
VUID-vkDestroyFence-fence-01122
If no VkAllocationCallbacks were provided when fence was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyFence-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyFence-fence-parameter
If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle
VUID-vkDestroyFence-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyFence-fence-parent
If fence is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to fence must be externally synchronized

To query the status of a fence from the host, call:

VkResult vkGetFenceStatus(
    VkDevice                                    device,
    VkFence                                     fence);

device is the logical device that owns the fence.
fence is the handle of the fence to query.

Upon success, vkGetFenceStatus returns the status of the fence object, with the following return codes:

Table 5. Fence Object Status Codes
Status	Meaning
`VK_SUCCESS`	The fence specified by `fence` is signaled.
`VK_NOT_READY`	The fence specified by `fence` is unsignaled.
`VK_ERROR_DEVICE_LOST`	The device has been lost. See Lost Device.

If a queue submission command is pending execution, then the value returned by this command may immediately be out of date.

If the device has been lost (see Lost Device), vkGetFenceStatus may return any of the above status codes. If the device has been lost and vkGetFenceStatus is called repeatedly, it will eventually return either VK_SUCCESS or VK_ERROR_DEVICE_LOST.

Valid Usage (Implicit)

VUID-vkGetFenceStatus-device-parameter
device must be a valid VkDevice handle
VUID-vkGetFenceStatus-fence-parameter
fence must be a valid VkFence handle
VUID-vkGetFenceStatus-fence-parent
fence must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS
VK_NOT_READY

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST

To set the state of fences to unsignaled from the host, call:

VkResult vkResetFences(
    VkDevice                                    device,
    uint32_t                                    fenceCount,
    const VkFence*                              pFences);

device is the logical device that owns the fences.
fenceCount is the number of fences to reset.
pFences is a pointer to an array of fence handles to reset.

If any member of pFences currently has its payload imported with temporary permanence, that fence’s prior permanent payload is first restored. The remaining operations described therefore operate on the restored payload.

When vkResetFences is executed on the host, it defines a fence unsignal operation for each fence, which resets the fence to the unsignaled state.

If any member of pFences is already in the unsignaled state when vkResetFences is executed, then vkResetFences has no effect on that fence.

Valid Usage

VUID-vkResetFences-pFences-01123
Each element of pFences must not be currently associated with any queue command that has not yet completed execution on that queue

Valid Usage (Implicit)

VUID-vkResetFences-device-parameter
device must be a valid VkDevice handle
VUID-vkResetFences-pFences-parameter
pFences must be a valid pointer to an array of fenceCount valid VkFence handles
VUID-vkResetFences-fenceCount-arraylength
fenceCount must be greater than 0
VUID-vkResetFences-pFences-parent
Each element of pFences must have been created, allocated, or retrieved from device

Host Synchronization

Host access to each member of pFences must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

When a fence is submitted to a queue as part of a queue submission command, it defines a memory dependency on the batches that were submitted as part of that command, and defines a fence signal operation which sets the fence to the signaled state.

The first synchronization scope includes every batch submitted in the same queue submission command. Fence signal operations that are defined by vkQueueSubmit additionally include in the first synchronization scope all commands that occur earlier in submission order. Fence signal operations that are defined by vkQueueSubmit or vkQueueBindSparse additionally include in the first synchronization scope any semaphore and fence signal operations that occur earlier in signal operation order.

The second synchronization scope only includes the fence signal operation.

The first access scope includes all memory access performed by the device.

The second access scope is empty.

To wait for one or more fences to enter the signaled state on the host, call:

VkResult vkWaitForFences(
    VkDevice                                    device,
    uint32_t                                    fenceCount,
    const VkFence*                              pFences,
    VkBool32                                    waitAll,
    uint64_t                                    timeout);

device is the logical device that owns the fences.
fenceCount is the number of fences to wait on.
pFences is a pointer to an array of fenceCount fence handles.
waitAll is the condition that must be satisfied to successfully unblock the wait. If waitAll is VK_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 is 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.

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. VK_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 VK_TIMEOUT. If the condition is satisfied before timeout nanoseconds has expired, vkWaitForFences returns VK_SUCCESS.

If device loss occurs (see Lost Device) before the timeout has expired, vkWaitForFences must return in finite time with either VK_SUCCESS or VK_ERROR_DEVICE_LOST.

Note

While we guarantee that vkWaitForFences must return in finite time, no guarantees are made that it returns immediately upon device loss. However, the client can reasonably expect that the delay will be on the order of seconds and that calling vkWaitForFences will not result in a permanently (or seemingly permanently) dead process.

Valid Usage (Implicit)

VUID-vkWaitForFences-device-parameter
device must be a valid VkDevice handle
VUID-vkWaitForFences-pFences-parameter
pFences must be a valid pointer to an array of fenceCount valid VkFence handles
VUID-vkWaitForFences-fenceCount-arraylength
fenceCount must be greater than 0
VUID-vkWaitForFences-pFences-parent
Each element of pFences must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS
VK_TIMEOUT

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST

An execution dependency is defined by waiting for a fence to become signaled, either via vkWaitForFences or by polling on vkGetFenceStatus.

The first synchronization scope includes only the fence signal operation.

The second synchronization scope includes the host operations of vkWaitForFences or vkGetFenceStatus indicating that the fence has become signaled.

Note

Signaling a fence and waiting on the host does not guarantee that the results of memory accesses will be visible to the host, as the access scope of a memory dependency defined by a fence only includes device access. A memory barrier or other memory dependency must be used to guarantee this. See the description of host access types for more information.

6.3.1. Alternate Methods to Signal Fences

Besides submitting a fence to a queue as part of a queue submission command, a fence may also be signaled when a particular event occurs on a device or display.

To create a fence that will be signaled when an event occurs on a device, call:

VkResult vkRegisterDeviceEventEXT(
    VkDevice                                    device,
    const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkFence*                                    pFence);

device is a logical device on which the event may occur.
pDeviceEventInfo is a pointer to a VkDeviceEventInfoEXT structure describing the event of interest to the application.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pFence is a pointer to a handle in which the resulting fence object is returned.

Valid Usage (Implicit)

VUID-vkRegisterDeviceEventEXT-device-parameter
device must be a valid VkDevice handle
VUID-vkRegisterDeviceEventEXT-pDeviceEventInfo-parameter
pDeviceEventInfo must be a valid pointer to a valid VkDeviceEventInfoEXT structure
VUID-vkRegisterDeviceEventEXT-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkRegisterDeviceEventEXT-pFence-parameter
pFence must be a valid pointer to a VkFence handle

Return Codes

VK_SUCCESS

The VkDeviceEventInfoEXT structure is defined as:

typedef struct VkDeviceEventInfoEXT {
    VkStructureType         sType;
    const void*             pNext;
    VkDeviceEventTypeEXT    deviceEvent;
} VkDeviceEventInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
device is a VkDeviceEventTypeEXT value specifying when the fence will be signaled.

Valid Usage (Implicit)

VUID-VkDeviceEventInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT
VUID-VkDeviceEventInfoEXT-pNext-pNext
pNext must be NULL
VUID-VkDeviceEventInfoEXT-deviceEvent-parameter
deviceEvent must be a valid VkDeviceEventTypeEXT value

Possible values of VkDeviceEventInfoEXT::device, specifying when a fence will be signaled, are:

typedef enum VkDeviceEventTypeEXT {
    VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0,
    VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
} VkDeviceEventTypeEXT;

VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT specifies that the fence is signaled when a display is plugged into or unplugged from the specified device. Applications can use this notification to determine when they need to re-enumerate the available displays on a device.

To create a fence that will be signaled when an event occurs on a VkDisplayKHR object, call:

VkResult vkRegisterDisplayEventEXT(
    VkDevice                                    device,
    VkDisplayKHR                                display,
    const VkDisplayEventInfoEXT*                pDisplayEventInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkFence*                                    pFence);

device is a logical device associated with display
display is the display on which the event may occur.
pDisplayEventInfo is a pointer to a VkDisplayEventInfoEXT structure describing the event of interest to the application.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pFence is a pointer to a handle in which the resulting fence object is returned.

Valid Usage (Implicit)

VUID-vkRegisterDisplayEventEXT-device-parameter
device must be a valid VkDevice handle
VUID-vkRegisterDisplayEventEXT-display-parameter
display must be a valid VkDisplayKHR handle
VUID-vkRegisterDisplayEventEXT-pDisplayEventInfo-parameter
pDisplayEventInfo must be a valid pointer to a valid VkDisplayEventInfoEXT structure
VUID-vkRegisterDisplayEventEXT-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkRegisterDisplayEventEXT-pFence-parameter
pFence must be a valid pointer to a VkFence handle

Return Codes

VK_SUCCESS

The VkDisplayEventInfoEXT structure is defined as:

typedef struct VkDisplayEventInfoEXT {
    VkStructureType          sType;
    const void*              pNext;
    VkDisplayEventTypeEXT    displayEvent;
} VkDisplayEventInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
displayEvent is a VkDisplayEventTypeEXT specifying when the fence will be signaled.

Valid Usage (Implicit)

VUID-VkDisplayEventInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT
VUID-VkDisplayEventInfoEXT-pNext-pNext
pNext must be NULL
VUID-VkDisplayEventInfoEXT-displayEvent-parameter
displayEvent must be a valid VkDisplayEventTypeEXT value

Possible values of VkDisplayEventInfoEXT::displayEvent, specifying when a fence will be signaled, are:

typedef enum VkDisplayEventTypeEXT {
    VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0,
    VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
} VkDisplayEventTypeEXT;

VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT specifies that the fence is signaled when the first pixel of the next display refresh cycle leaves the display engine for the display.

6.3.2. Importing Fence Payloads

Applications can import a fence payload into an existing fence using an external fence handle. The effects of the import operation will be either temporary or permanent, as specified by the application. If the import is temporary, the fence will be restored to its permanent state the next time that fence is passed to vkResetFences.

Note

Restoring a fence to its prior permanent payload is a distinct operation from resetting a fence payload. See vkResetFences for more detail.

Performing a subsequent temporary import on a fence before resetting it has no effect on this requirement; the next unsignal of the fence must still restore its last permanent state. A permanent payload import behaves as if the target fence was destroyed, and a new fence was created with the same handle but the imported payload. Because importing a fence payload temporarily or permanently detaches the existing payload from a fence, similar usage restrictions to those applied to vkDestroyFence are applied to any command that imports a fence payload. Which of these import types is used is referred to as the import operation’s permanence. Each handle type supports either one or both types of permanence.

The implementation must perform the import operation by either referencing or copying the payload referred to by the specified external fence handle, depending on the handle’s type. The import method used is referred to as the handle type’s transference. When using handle types with reference transference, importing a payload to a fence adds the fence to the set of all fences sharing that payload. This set includes the fence from which the payload was exported. Fence signaling, waiting, and resetting operations performed on any fence in the set must behave as if the set were a single fence. Importing a payload using handle types with copy transference creates a duplicate copy of the payload at the time of import, but makes no further reference to it. Fence signaling, waiting, and resetting operations performed on the target of copy imports must not affect any other fence or payload.

Export operations have the same transference as the specified handle type’s import operations. Additionally, exporting a fence payload to a handle with copy transference has the same side effects on the source fence’s payload as executing a fence reset operation. If the fence was using a temporarily imported payload, the fence’s prior permanent payload will be restored.

Note

The tables Handle Types Supported by VkImportFenceWin32HandleInfoKHR and Handle Types Supported by VkImportFenceFdInfoKHR define the permanence and transference of each handle type.

External synchronization allows implementations to modify an object’s internal state, i.e. payload, without internal synchronization. However, for fences sharing a payload across processes, satisfying the external synchronization requirements of VkFence parameters as if all fences in the set were the same object is sometimes infeasible. Satisfying valid usage constraints on the state of a fence would similarly require impractical coordination or levels of trust between processes. Therefore, these constraints only apply to a specific fence handle, not to its payload. For distinct fence objects which share a payload:

If multiple commands which queue a signal operation, or which unsignal a fence, are called concurrently, behavior will be as if the commands were called in an arbitrary sequential order.
If a queue submission command is called with a fence that is sharing a payload, and the payload is already associated with another queue command that has not yet completed execution, either one or both of the commands will cause the fence to become signaled when they complete execution.
If a fence payload is reset while it is associated with a queue command that has not yet completed execution, the payload will become unsignaled, but may become signaled again when the command completes execution.
In the preceding cases, any of the devices associated with the fences sharing the payload may be lost, or any of the queue submission or fence reset commands may return VK_ERROR_INITIALIZATION_FAILED.

Other than these non-deterministic results, behavior is well defined. In particular:

The implementation must not crash or enter an internally inconsistent state where future valid Vulkan commands might cause undefined results,
Timeouts on future wait commands on fences sharing the payload must be effective.

Note

These rules allow processes to synchronize access to shared memory without trusting each other. However, such processes must still be cautious not to use the shared fence for more than synchronizing access to the shared memory. For example, a process should not use a fence with shared payload to tell when commands it submitted to a queue have completed and objects used by those commands may be destroyed, since the other process can accidentally or maliciously cause the fence to signal before the commands actually complete.

When a fence is using an imported payload, its VkExportFenceCreateInfo::handleTypes value is that specified when creating the fence from which the payload was exported, rather than that specified when creating the fence. Additionally, VkExternalFenceProperties::exportFromImportedHandleTypes restricts which handle types can be exported from such a fence based on the specific handle type used to import the current payload. Passing a fence to vkAcquireNextImageKHR is equivalent to temporarily importing a fence payload to that fence.

Note

Because the exportable handle types of an imported fence correspond to its current imported payload, and vkAcquireNextImageKHR behaves the same as a temporary import operation for which the source fence is opaque to the application, applications have no way of determining whether any external handle types can be exported from a fence in this state. Therefore, applications must not attempt to export handles from fences using a temporarily imported payload from vkAcquireNextImageKHR.

When importing a fence payload, it is the responsibility of the application to ensure the external handles meet all valid usage requirements. However, implementations must perform sufficient validation of external handles to ensure that the operation results in a valid fence which will not cause program termination, device loss, queue stalls, host thread stalls, or corruption of other resources when used as allowed according to its import parameters. If the external handle provided does not meet these requirements, the implementation must fail the fence payload import operation with the error code VK_ERROR_INVALID_EXTERNAL_HANDLE.

To import a fence payload from a Windows handle, call:

VkResult vkImportFenceWin32HandleKHR(
    VkDevice                                    device,
    const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);

device is the logical device that created the fence.
pImportFenceWin32HandleInfo is a pointer to a VkImportFenceWin32HandleInfoKHR structure specifying the fence and import parameters.

Importing a fence payload from Windows handles does not transfer ownership of the handle to the Vulkan implementation. For handle types defined as NT handles, the application must release ownership using the CloseHandle system call when the handle is no longer needed.

Applications can import the same fence payload into multiple instances of Vulkan, into the same instance from which it was exported, and multiple times into a given Vulkan instance.

Valid Usage (Implicit)

VUID-vkImportFenceWin32HandleKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkImportFenceWin32HandleKHR-pImportFenceWin32HandleInfo-parameter
pImportFenceWin32HandleInfo must be a valid pointer to a valid VkImportFenceWin32HandleInfoKHR structure

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_INVALID_EXTERNAL_HANDLE

The VkImportFenceWin32HandleInfoKHR structure is defined as:

typedef struct VkImportFenceWin32HandleInfoKHR {
    VkStructureType                      sType;
    const void*                          pNext;
    VkFence                              fence;
    VkFenceImportFlags                   flags;
    VkExternalFenceHandleTypeFlagBits    handleType;
    HANDLE                               handle;
    LPCWSTR                              name;
} VkImportFenceWin32HandleInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
fence is the fence into which the state will be imported.
flags is a bitmask of VkFenceImportFlagBits specifying additional parameters for the fence payload import operation.
handleType specifies the type of handle.
handle is the external handle to import, or NULL.
name is a null-terminated UTF-16 string naming the underlying synchronization primitive to import, or NULL.

The handle types supported by handleType are:

Table 6. Handle Types Supported by VkImportFenceWin32HandleInfoKHR
Handle Type	Transference	Permanence Supported
`VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT`	Reference	Temporary,Permanent
`VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT`	Reference	Temporary,Permanent

Valid Usage

VUID-VkImportFenceWin32HandleInfoKHR-handleType-01457
handleType must be a value included in the Handle Types Supported by VkImportFenceWin32HandleInfoKHR table.
VUID-VkImportFenceWin32HandleInfoKHR-handleType-01459
If handleType is not VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, name must be NULL.
VUID-VkImportFenceWin32HandleInfoKHR-handleType-01460
If handleType is not 0 and handle is NULL, name must name a valid synchronization primitive of the type specified by handleType.
VUID-VkImportFenceWin32HandleInfoKHR-handleType-01461
If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType.
VUID-VkImportFenceWin32HandleInfoKHR-handle-01462
If handle is not NULL, name must be NULL.
VUID-VkImportFenceWin32HandleInfoKHR-handle-01539
If handle is not NULL, it must obey any requirements listed for handleType in external fence handle types compatibility.
VUID-VkImportFenceWin32HandleInfoKHR-name-01540
If name is not NULL, it must obey any requirements listed for handleType in external fence handle types compatibility.

Valid Usage (Implicit)

VUID-VkImportFenceWin32HandleInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR
VUID-VkImportFenceWin32HandleInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkImportFenceWin32HandleInfoKHR-fence-parameter
fence must be a valid VkFence handle
VUID-VkImportFenceWin32HandleInfoKHR-flags-parameter
flags must be a valid combination of VkFenceImportFlagBits values
VUID-VkImportFenceWin32HandleInfoKHR-handleType-parameter
If handleType is not 0, handleType must be a valid VkExternalFenceHandleTypeFlagBits value

Host Synchronization

Host access to fence must be externally synchronized

To import a fence payload from a POSIX file descriptor, call:

VkResult vkImportFenceFdKHR(
    VkDevice                                    device,
    const VkImportFenceFdInfoKHR*               pImportFenceFdInfo);

device is the logical device that created the fence.
pImportFenceFdInfo is a pointer to a VkImportFenceFdInfoKHR structure specifying the fence and import parameters.

Importing a fence payload from a file descriptor transfers ownership of the file descriptor from the application to the Vulkan implementation. The application must not perform any operations on the file descriptor after a successful import.

Applications can import the same fence payload into multiple instances of Vulkan, into the same instance from which it was exported, and multiple times into a given Vulkan instance.

Valid Usage

VUID-vkImportFenceFdKHR-fence-01463
fence must not be associated with any queue command that has not yet completed execution on that queue

Valid Usage (Implicit)

VUID-vkImportFenceFdKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkImportFenceFdKHR-pImportFenceFdInfo-parameter
pImportFenceFdInfo must be a valid pointer to a valid VkImportFenceFdInfoKHR structure

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_INVALID_EXTERNAL_HANDLE

The VkImportFenceFdInfoKHR structure is defined as:

typedef struct VkImportFenceFdInfoKHR {
    VkStructureType                      sType;
    const void*                          pNext;
    VkFence                              fence;
    VkFenceImportFlags                   flags;
    VkExternalFenceHandleTypeFlagBits    handleType;
    int                                  fd;
} VkImportFenceFdInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
fence is the fence into which the payload will be imported.
flags is a bitmask of VkFenceImportFlagBits specifying additional parameters for the fence payload import operation.
handleType specifies the type of fd.
fd is the external handle to import.

The handle types supported by handleType are:

Table 7. Handle Types Supported by VkImportFenceFdInfoKHR
Handle Type	Transference	Permanence Supported
`VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT`	Reference	Temporary,Permanent
`VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT`	Copy	Temporary

Valid Usage

VUID-VkImportFenceFdInfoKHR-handleType-01464
handleType must be a value included in the Handle Types Supported by VkImportFenceFdInfoKHR table.
VUID-VkImportFenceFdInfoKHR-fd-01541
fd must obey any requirements listed for handleType in external fence handle types compatibility.

If handleType is VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, the special value -1 for fd is treated like a valid sync file descriptor referring to an object that has already signaled. The import operation will succeed and the VkFence will have a temporarily imported payload as if a valid file descriptor had been provided.

Note

This special behavior for importing an invalid sync file descriptor allows easier interoperability with other system APIs which use the convention that an invalid sync file descriptor represents work that has already completed and does not need to be waited for. It is consistent with the option for implementations to return a -1 file descriptor when exporting a VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT from a VkFence which is signaled.

Valid Usage (Implicit)

VUID-VkImportFenceFdInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR
VUID-VkImportFenceFdInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkImportFenceFdInfoKHR-fence-parameter
fence must be a valid VkFence handle
VUID-VkImportFenceFdInfoKHR-flags-parameter
flags must be a valid combination of VkFenceImportFlagBits values
VUID-VkImportFenceFdInfoKHR-handleType-parameter
handleType must be a valid VkExternalFenceHandleTypeFlagBits value

Host Synchronization

Host access to fence must be externally synchronized

Bits which can be set in VkImportFenceWin32HandleInfoKHR::flags and VkImportFenceFdInfoKHR::flags specifying additional parameters of a fence import operation are:

typedef enum VkFenceImportFlagBits {
    VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001,
    VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT,
    VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkFenceImportFlagBits;

or the equivalent

typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR;

VK_FENCE_IMPORT_TEMPORARY_BIT specifies that the fence payload will be imported only temporarily, as described in Importing Fence Payloads, regardless of the permanence of handleType.

typedef VkFlags VkFenceImportFlags;

or the equivalent

typedef VkFenceImportFlags VkFenceImportFlagsKHR;

VkFenceImportFlags is a bitmask type for setting a mask of zero or more VkFenceImportFlagBits.

6.4. Semaphores

Semaphores are a synchronization primitive that can be used to insert a dependency between queue operations or between a queue operation and the host. Binary semaphores have two states - signaled and unsignaled. Timeline semaphores have a monotonically increasing 64-bit unsigned integer payload and are signaled with respect to a particular reference value. A semaphore can be signaled after execution of a queue operation is completed, and a queue operation can wait for a semaphore to become signaled before it begins execution. A timeline semaphore can additionally be signaled from the host with the vkSignalSemaphore command and waited on from the host with the vkWaitSemaphores command.

As with most objects in Vulkan, semaphores are an interface to internal data which is typically opaque to applications. This internal data is referred to as a semaphore’s payload.

The internal data of a semaphore may include a reference to any resources and pending work associated with signal or unsignal operations performed on that semaphore object. Mechanisms to import and export that internal data to and from semaphores are provided below. These mechanisms indirectly enable applications to share semaphore state between two or more semaphores and other synchronization primitives across process and API boundaries.

Semaphores are represented by VkSemaphore handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)

To create a semaphore, call:

VkResult vkCreateSemaphore(
    VkDevice                                    device,
    const VkSemaphoreCreateInfo*                pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSemaphore*                                pSemaphore);

device is the logical device that creates the semaphore.
pCreateInfo is a pointer to a VkSemaphoreCreateInfo structure containing information about how the semaphore is to be created.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pSemaphore is a pointer to a handle in which the resulting semaphore object is returned.

Valid Usage (Implicit)

VUID-vkCreateSemaphore-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateSemaphore-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkSemaphoreCreateInfo structure
VUID-vkCreateSemaphore-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateSemaphore-pSemaphore-parameter
pSemaphore must be a valid pointer to a VkSemaphore handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkSemaphoreCreateInfo structure is defined as:

typedef struct VkSemaphoreCreateInfo {
    VkStructureType           sType;
    const void*               pNext;
    VkSemaphoreCreateFlags    flags;
} VkSemaphoreCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.

Valid Usage (Implicit)

VUID-VkSemaphoreCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
VUID-VkSemaphoreCreateInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExportSemaphoreCreateInfo, VkExportSemaphoreWin32HandleInfoKHR, or VkSemaphoreTypeCreateInfo
VUID-VkSemaphoreCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkSemaphoreCreateInfo-flags-zerobitmask
flags must be 0

typedef VkFlags VkSemaphoreCreateFlags;

VkSemaphoreCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

To create a semaphore of a specific type, add a VkSemaphoreTypeCreateInfo structure to the pNext chain of the VkSemaphoreCreateInfo structure. The VkSemaphoreTypeCreateInfo structure is defined as:

typedef struct VkSemaphoreTypeCreateInfo {
    VkStructureType    sType;
    const void*        pNext;
    VkSemaphoreType    semaphoreType;
    uint64_t           initialValue;
} VkSemaphoreTypeCreateInfo;

or the equivalent

typedef VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
semaphoreType is a VkSemaphoreType value specifying the type of the semaphore.
initialValue is the initial payload value if semaphoreType is VK_SEMAPHORE_TYPE_TIMELINE.

Valid Usage (Implicit)

VUID-VkSemaphoreTypeCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO
VUID-VkSemaphoreTypeCreateInfo-semaphoreType-parameter
semaphoreType must be a valid VkSemaphoreType value

Valid Usage

VUID-VkSemaphoreTypeCreateInfo-timelineSemaphore-03252
If the timelineSemaphore feature is not enabled, semaphoreType must not equal VK_SEMAPHORE_TYPE_TIMELINE
VUID-VkSemaphoreTypeCreateInfo-semaphoreType-03279
If semaphoreType is VK_SEMAPHORE_TYPE_BINARY, initialValue must be zero.

If no VkSemaphoreTypeCreateInfo structure is included in the pNext chain of VkSemaphoreCreateInfo, then the created semaphore will have a default VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY.

Possible values of VkSemaphoreTypeCreateInfo::semaphoreType, specifying the type of a semaphore, are:

typedef enum VkSemaphoreType {
    VK_SEMAPHORE_TYPE_BINARY = 0,
    VK_SEMAPHORE_TYPE_TIMELINE = 1,
    VK_SEMAPHORE_TYPE_BINARY_KHR = VK_SEMAPHORE_TYPE_BINARY,
    VK_SEMAPHORE_TYPE_TIMELINE_KHR = VK_SEMAPHORE_TYPE_TIMELINE,
    VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkSemaphoreType;

or the equivalent

typedef VkSemaphoreType VkSemaphoreTypeKHR;

VK_SEMAPHORE_TYPE_BINARY specifies a binary semaphore type that has a boolean payload indicating whether the semaphore is currently signaled or unsignaled. When created, the semaphore is in the unsignaled state.
VK_SEMAPHORE_TYPE_TIMELINE specifies a timeline semaphore type that has a monotonically increasing 64-bit unsigned integer payload indicating whether the semaphore is signaled with respect to a particular reference value. When created, the semaphore payload has the value given by the initialValue field of VkSemaphoreTypeCreateInfo.

To create a semaphore whose payload can be exported to external handles, add a VkExportSemaphoreCreateInfo structure to the pNext chain of the VkSemaphoreCreateInfo structure. The VkExportSemaphoreCreateInfo structure is defined as:

typedef struct VkExportSemaphoreCreateInfo {
    VkStructureType                       sType;
    const void*                           pNext;
    VkExternalSemaphoreHandleTypeFlags    handleTypes;
} VkExportSemaphoreCreateInfo;

or the equivalent

typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
handleTypes is a bitmask of VkExternalSemaphoreHandleTypeFlagBits specifying one or more semaphore handle types the application can export from the resulting semaphore. The application can request multiple handle types for the same semaphore.

Valid Usage

VUID-VkExportSemaphoreCreateInfo-handleTypes-01124
The bits in handleTypes must be supported and compatible, as reported by VkExternalSemaphoreProperties.

Valid Usage (Implicit)

VUID-VkExportSemaphoreCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO
VUID-VkExportSemaphoreCreateInfo-handleTypes-parameter
handleTypes must be a valid combination of VkExternalSemaphoreHandleTypeFlagBits values

To specify additional attributes of NT handles exported from a semaphore, add a VkExportSemaphoreWin32HandleInfoKHR structure to the pNext chain of the VkSemaphoreCreateInfo structure. The VkExportSemaphoreWin32HandleInfoKHR structure is defined as:

typedef struct VkExportSemaphoreWin32HandleInfoKHR {
    VkStructureType               sType;
    const void*                   pNext;
    const SECURITY_ATTRIBUTES*    pAttributes;
    DWORD                         dwAccess;
    LPCWSTR                       name;
} VkExportSemaphoreWin32HandleInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
pAttributes is a pointer to a Windows SECURITY_ATTRIBUTES structure specifying security attributes of the handle.
dwAccess is a DWORD specifying access rights of the handle.
name is a null-terminated UTF-16 string to associate with the underlying synchronization primitive referenced by NT handles exported from the created semaphore.

For handles of the following types:

VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT

The implementation must ensure the access rights allow both signal and wait operations on the semaphore.

For handles of the following types:

VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT

The access rights must be:

GENERIC_ALL

1: https://docs.microsoft.com/en-us/windows/win32/sync/synchronization-object-security-and-access-rights

Valid Usage

VUID-VkExportSemaphoreWin32HandleInfoKHR-handleTypes-01125
If VkExportSemaphoreCreateInfo::handleTypes does not include VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, VkExportSemaphoreWin32HandleInfoKHR must not be included in the pNext chain of VkSemaphoreCreateInfo.

Valid Usage (Implicit)

VUID-VkExportSemaphoreWin32HandleInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR
VUID-VkExportSemaphoreWin32HandleInfoKHR-pAttributes-parameter
If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value

To export a Windows handle representing the payload of a semaphore, call:

VkResult vkGetSemaphoreWin32HandleKHR(
    VkDevice                                    device,
    const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
    HANDLE*                                     pHandle);

device is the logical device that created the semaphore being exported.
pGetWin32HandleInfo is a pointer to a VkSemaphoreGetWin32HandleInfoKHR structure containing parameters of the export operation.
pHandle will return the Windows handle representing the semaphore state.

For handle types defined as NT handles, the handles returned by vkGetSemaphoreWin32HandleKHR are owned by the application. To avoid leaking resources, the application must release ownership of them using the CloseHandle system call when they are no longer needed.

Exporting a Windows handle from a semaphore may have side effects depending on the transference of the specified handle type, as described in Importing Semaphore Payloads.

Valid Usage (Implicit)

VUID-vkGetSemaphoreWin32HandleKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkGetSemaphoreWin32HandleKHR-pGetWin32HandleInfo-parameter
pGetWin32HandleInfo must be a valid pointer to a valid VkSemaphoreGetWin32HandleInfoKHR structure
VUID-vkGetSemaphoreWin32HandleKHR-pHandle-parameter
pHandle must be a valid pointer to a HANDLE value

Return Codes

VK_SUCCESS

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

The VkSemaphoreGetWin32HandleInfoKHR structure is defined as:

typedef struct VkSemaphoreGetWin32HandleInfoKHR {
    VkStructureType                          sType;
    const void*                              pNext;
    VkSemaphore                              semaphore;
    VkExternalSemaphoreHandleTypeFlagBits    handleType;
} VkSemaphoreGetWin32HandleInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
semaphore is the semaphore from which state will be exported.
handleType is the type of handle requested.

The properties of the handle returned depend on the value of handleType. See VkExternalSemaphoreHandleTypeFlagBits for a description of the properties of the defined external semaphore handle types.

Valid Usage

VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01126
handleType must have been included in VkExportSemaphoreCreateInfo::handleTypes when the semaphore’s current payload was created.
VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01127
If handleType is defined as an NT handle, vkGetSemaphoreWin32HandleKHR must be called no more than once for each valid unique combination of semaphore and handleType.
VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-01128
semaphore must not currently have its payload replaced by an imported payload as described below in Importing Semaphore Payloads unless that imported payload’s handle type was included in VkExternalSemaphoreProperties::exportFromImportedHandleTypes for handleType.
VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01129
If handleType refers to a handle type with copy payload transference semantics, as defined below in Importing Semaphore Payloads, there must be no queue waiting on semaphore.
VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01130
If handleType refers to a handle type with copy payload transference semantics, semaphore must be signaled, or have an associated semaphore signal operation pending execution.
VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01131
handleType must be defined as an NT handle or a global share handle.

Valid Usage (Implicit)

VUID-VkSemaphoreGetWin32HandleInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR
VUID-VkSemaphoreGetWin32HandleInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-parameter
semaphore must be a valid VkSemaphore handle
VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-parameter
handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value

To export a POSIX file descriptor representing the payload of a semaphore, call:

VkResult vkGetSemaphoreFdKHR(
    VkDevice                                    device,
    const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
    int*                                        pFd);

device is the logical device that created the semaphore being exported.
pGetFdInfo is a pointer to a VkSemaphoreGetFdInfoKHR structure containing parameters of the export operation.
pFd will return the file descriptor representing the semaphore payload.

Each call to vkGetSemaphoreFdKHR must create a new file descriptor and transfer ownership of it to the application. To avoid leaking resources, the application must release ownership of the file descriptor when it is no longer needed.

Note

Where supported by the operating system, the implementation must set the file descriptor to be closed automatically when an execve system call is made.

Exporting a file descriptor from a semaphore may have side effects depending on the transference of the specified handle type, as described in Importing Semaphore State.

Valid Usage (Implicit)

VUID-vkGetSemaphoreFdKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkGetSemaphoreFdKHR-pGetFdInfo-parameter
pGetFdInfo must be a valid pointer to a valid VkSemaphoreGetFdInfoKHR structure
VUID-vkGetSemaphoreFdKHR-pFd-parameter
pFd must be a valid pointer to an int value

Return Codes

VK_SUCCESS

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

The VkSemaphoreGetFdInfoKHR structure is defined as:

typedef struct VkSemaphoreGetFdInfoKHR {
    VkStructureType                          sType;
    const void*                              pNext;
    VkSemaphore                              semaphore;
    VkExternalSemaphoreHandleTypeFlagBits    handleType;
} VkSemaphoreGetFdInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
semaphore is the semaphore from which state will be exported.
handleType is the type of handle requested.

The properties of the file descriptor returned depend on the value of handleType. See VkExternalSemaphoreHandleTypeFlagBits for a description of the properties of the defined external semaphore handle types.

Valid Usage

VUID-VkSemaphoreGetFdInfoKHR-handleType-01132
handleType must have been included in VkExportSemaphoreCreateInfo::handleTypes when semaphore’s current payload was created.
VUID-VkSemaphoreGetFdInfoKHR-semaphore-01133
semaphore must not currently have its payload replaced by an imported payload as described below in Importing Semaphore Payloads unless that imported payload’s handle type was included in VkExternalSemaphoreProperties::exportFromImportedHandleTypes for handleType.
VUID-VkSemaphoreGetFdInfoKHR-handleType-01134
If handleType refers to a handle type with copy payload transference semantics, as defined below in Importing Semaphore Payloads, there must be no queue waiting on semaphore.
VUID-VkSemaphoreGetFdInfoKHR-handleType-01135
If handleType refers to a handle type with copy payload transference semantics, semaphore must be signaled, or have an associated semaphore signal operation pending execution.
VUID-VkSemaphoreGetFdInfoKHR-handleType-01136
handleType must be defined as a POSIX file descriptor handle.
VUID-VkSemaphoreGetFdInfoKHR-handleType-03253
If handleType refers to a handle type with copy payload transference semantics, semaphore must have been created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY.
VUID-VkSemaphoreGetFdInfoKHR-handleType-03254
If handleType refers to a handle type with copy payload transference semantics, semaphore must have an associated semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) must have also been submitted for execution.

Valid Usage (Implicit)

VUID-VkSemaphoreGetFdInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR
VUID-VkSemaphoreGetFdInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkSemaphoreGetFdInfoKHR-semaphore-parameter
semaphore must be a valid VkSemaphore handle
VUID-VkSemaphoreGetFdInfoKHR-handleType-parameter
handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value

To destroy a semaphore, call:

void vkDestroySemaphore(
    VkDevice                                    device,
    VkSemaphore                                 semaphore,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the semaphore.
semaphore is the handle of the semaphore to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroySemaphore-semaphore-01137
All submitted batches that refer to semaphore must have completed execution
VUID-vkDestroySemaphore-semaphore-01138
If VkAllocationCallbacks were provided when semaphore was created, a compatible set of callbacks must be provided here
VUID-vkDestroySemaphore-semaphore-01139
If no VkAllocationCallbacks were provided when semaphore was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroySemaphore-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroySemaphore-semaphore-parameter
If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle
VUID-vkDestroySemaphore-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroySemaphore-semaphore-parent
If semaphore is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to semaphore must be externally synchronized

6.4.1. Semaphore Signaling

When a batch is submitted to a queue via a queue submission, and it includes semaphores to be signaled, it defines a memory dependency on the batch, and defines semaphore signal operations which set the semaphores to the signaled state.

In case of semaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE the semaphore is considered signaled with respect to the counter value set to be signaled as specified in VkTimelineSemaphoreSubmitInfo or VkSemaphoreSignalInfo.

The first synchronization scope includes every command submitted in the same batch. Semaphore signal operations that are defined by vkQueueSubmit additionally include all commands that occur earlier in submission order. Semaphore signal operations that are defined by vkQueueSubmit or vkQueueBindSparse additionally include in the first synchronization scope any semaphore and fence signal operations that occur earlier in signal operation order.

The second synchronization scope includes only the semaphore signal operation.

The first access scope includes all memory access performed by the device.

The second access scope is empty.

6.4.2. Semaphore Waiting

When a batch is submitted to a queue via a queue submission, and it includes semaphores to be waited on, it defines a memory dependency between prior semaphore signal operations and the batch, and defines semaphore wait operations.

Such semaphore wait operations set the semaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY to the unsignaled state. In case of semaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE a prior semaphore signal operation defines a memory dependency with a semaphore wait operation if the value the semaphore is signaled with is greater than or equal to the value the semaphore is waited with, thus the semaphore will continue to be considered signaled with respect to the counter value waited on as specified in VkTimelineSemaphoreSubmitInfo.

The first synchronization scope includes all semaphore signal operations that operate on semaphores waited on in the same batch, and that happen-before the wait completes.

The second synchronization scope includes every command submitted in the same batch. In the case of vkQueueSubmit, the second synchronization scope is limited to operations on the pipeline stages determined by the destination stage mask specified by the corresponding element of pWaitDstStageMask. Also, in the case of vkQueueSubmit, the second synchronization scope additionally includes all commands that occur later in submission order.

The first access scope is empty.

The second access scope includes all memory access performed by the device.

The semaphore wait operation happens-after the first set of operations in the execution dependency, and happens-before the second set of operations in the execution dependency.

Note

Unlike timeline semaphores, fences or events, the act of waiting for a binary semaphore also unsignals that semaphore. Applications must ensure that between two such wait operations, the semaphore is signaled again, with execution dependencies used to ensure these occur in order. Binary semaphore waits and signals should thus occur in discrete 1:1 pairs.

Note

A common scenario for using pWaitDstStageMask with values other than VK_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, a presentation image must not be overwritten until the presentation operation completes, but other pipeline stages can execute without waiting. A mask of VK_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 presentable 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:

srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
srcAccessMask = 0
dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT.
oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL

Alternatively, oldLayout can be VK_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, the semaphore wait stalls the VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT stage, and there is a dependency from that same stage to itself with the layout transition performed in between.

6.4.3. Semaphore State Requirements For Wait Operations

Before waiting on a semaphore, the application must ensure the semaphore is in a valid state for a wait operation. Specifically, when a semaphore wait operation is submitted to a queue:

A binary semaphore must be signaled, or have an associated semaphore signal operation that is pending execution.
Any semaphore signal operations on which the pending binary semaphore signal operation depends must also be completed or pending execution.
There must be no other queue waiting on the same binary semaphore when the operation executes.

6.4.4. Host Operations on Semaphores

In addition to semaphore signal operations and semaphore wait operations submitted to device queues, timeline semaphores support the following host operations:

Query the current counter value of the semaphore using the vkGetSemaphoreCounterValue command.
Wait for a set of semaphores to reach particular counter values using the vkWaitSemaphores command.
Signal the semaphore with a particular counter value from the host using the vkSignalSemaphore command.

To query the current counter value of a semaphore created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE from the host, call:

VkResult vkGetSemaphoreCounterValue(
    VkDevice                                    device,
    VkSemaphore                                 semaphore,
    uint64_t*                                   pValue);

or the equivalent command

VkResult vkGetSemaphoreCounterValueKHR(
    VkDevice                                    device,
    VkSemaphore                                 semaphore,
    uint64_t*                                   pValue);

device is the logical device that owns the semaphore.
semaphore is the handle of the semaphore to query.
pValue is a pointer to a 64-bit integer value in which the current counter value of the semaphore is returned.

Note

If a queue submission command is pending execution, then the value returned by this command may immediately be out of date.

Valid Usage

VUID-vkGetSemaphoreCounterValue-semaphore-03255
semaphore must have been created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE

Valid Usage (Implicit)

VUID-vkGetSemaphoreCounterValue-device-parameter
device must be a valid VkDevice handle
VUID-vkGetSemaphoreCounterValue-semaphore-parameter
semaphore must be a valid VkSemaphore handle
VUID-vkGetSemaphoreCounterValue-pValue-parameter
pValue must be a valid pointer to a uint64_t value
VUID-vkGetSemaphoreCounterValue-semaphore-parent
semaphore must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST

To wait for a set of semaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE to reach particular counter values on the host, call:

VkResult vkWaitSemaphores(
    VkDevice                                    device,
    const VkSemaphoreWaitInfo*                  pWaitInfo,
    uint64_t                                    timeout);

or the equivalent command

VkResult vkWaitSemaphoresKHR(
    VkDevice                                    device,
    const VkSemaphoreWaitInfo*                  pWaitInfo,
    uint64_t                                    timeout);

device is the logical device that owns the semaphore.
pWaitInfo is a pointer to a VkSemaphoreWaitInfo structure containing information about the wait condition.
timeout is 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.

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

If timeout is zero, then vkWaitSemaphores does not wait, but simply returns information about the current state of the semaphore. VK_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, vkWaitSemaphores returns VK_TIMEOUT. If the condition is satisfied before timeout nanoseconds has expired, vkWaitSemaphores returns VK_SUCCESS.

If device loss occurs (see Lost Device) before the timeout has expired, vkWaitSemaphores must return in finite time with either VK_SUCCESS or VK_ERROR_DEVICE_LOST.

Valid Usage (Implicit)

VUID-vkWaitSemaphores-device-parameter
device must be a valid VkDevice handle
VUID-vkWaitSemaphores-pWaitInfo-parameter
pWaitInfo must be a valid pointer to a valid VkSemaphoreWaitInfo structure

Return Codes

VK_SUCCESS
VK_TIMEOUT

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST

The VkSemaphoreWaitInfo structure is defined as:

typedef struct VkSemaphoreWaitInfo {
    VkStructureType         sType;
    const void*             pNext;
    VkSemaphoreWaitFlags    flags;
    uint32_t                semaphoreCount;
    const VkSemaphore*      pSemaphores;
    const uint64_t*         pValues;
} VkSemaphoreWaitInfo;

or the equivalent

typedef VkSemaphoreWaitInfo VkSemaphoreWaitInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkSemaphoreWaitFlagBits specifying additional parameters for the semaphore wait operation.
semaphoreCount is the number of semaphores to wait on.
pSemaphores is a pointer to an array of semaphoreCount semaphore handles to wait on.
pValues is a pointer to an array of semaphoreCount timeline semaphore values.

Valid Usage

VUID-VkSemaphoreWaitInfo-pSemaphores-03256
All of the elements of pSemaphores must reference a semaphore that was created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE

Valid Usage (Implicit)

VUID-VkSemaphoreWaitInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO
VUID-VkSemaphoreWaitInfo-pNext-pNext
pNext must be NULL
VUID-VkSemaphoreWaitInfo-flags-parameter
flags must be a valid combination of VkSemaphoreWaitFlagBits values
VUID-VkSemaphoreWaitInfo-pSemaphores-parameter
pSemaphores must be a valid pointer to an array of semaphoreCount valid VkSemaphore handles
VUID-VkSemaphoreWaitInfo-pValues-parameter
pValues must be a valid pointer to an array of semaphoreCount uint64_t values
VUID-VkSemaphoreWaitInfo-semaphoreCount-arraylength
semaphoreCount must be greater than 0

Bits which can be set in VkSemaphoreWaitInfo::flags, specifying additional parameters of a semaphore wait operation, are:

typedef enum VkSemaphoreWaitFlagBits {
    VK_SEMAPHORE_WAIT_ANY_BIT = 0x00000001,
    VK_SEMAPHORE_WAIT_ANY_BIT_KHR = VK_SEMAPHORE_WAIT_ANY_BIT,
    VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkSemaphoreWaitFlagBits;

or the equivalent

typedef VkSemaphoreWaitFlagBits VkSemaphoreWaitFlagBitsKHR;

VK_SEMAPHORE_WAIT_ANY_BIT specifies that the semaphore wait condition is that at least one of the semaphores in VkSemaphoreWaitInfo::pSemaphores has reached the value specified by the corresponding element of VkSemaphoreWaitInfo::pValues. If VK_SEMAPHORE_WAIT_ANY_BIT is not set, the semaphore wait condition is that all of the semaphores in VkSemaphoreWaitInfo::pSemaphores have reached the value specified by the corresponding element of VkSemaphoreWaitInfo::pValues.

typedef VkFlags VkSemaphoreWaitFlags;

or the equivalent

typedef VkSemaphoreWaitFlags VkSemaphoreWaitFlagsKHR;

VkSemaphoreWaitFlags is a bitmask type for setting a mask of zero or more VkSemaphoreWaitFlagBits.

To signal a semaphore created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE with a particular counter value, on the host, call:

VkResult vkSignalSemaphore(
    VkDevice                                    device,
    const VkSemaphoreSignalInfo*                pSignalInfo);

or the equivalent command

VkResult vkSignalSemaphoreKHR(
    VkDevice                                    device,
    const VkSemaphoreSignalInfo*                pSignalInfo);

device is the logical device that owns the semaphore.
pSignalInfo is a pointer to a VkSemaphoreSignalInfo structure containing information about the signal operation.

When vkSignalSemaphore is executed on the host, it defines and immediately executes a semaphore signal operation which sets the timeline semaphore to the given value.

The first synchronization scope is defined by the host execution model, but includes execution of vkSignalSemaphore on the host and anything that happened-before it.

The second synchronization scope is empty.

Valid Usage (Implicit)

VUID-vkSignalSemaphore-device-parameter
device must be a valid VkDevice handle
VUID-vkSignalSemaphore-pSignalInfo-parameter
pSignalInfo must be a valid pointer to a valid VkSemaphoreSignalInfo structure

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkSemaphoreSignalInfo structure is defined as:

typedef struct VkSemaphoreSignalInfo {
    VkStructureType    sType;
    const void*        pNext;
    VkSemaphore        semaphore;
    uint64_t           value;
} VkSemaphoreSignalInfo;

or the equivalent

typedef VkSemaphoreSignalInfo VkSemaphoreSignalInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
semaphore is the handle of the semaphore to signal.
value is the value to signal.

Valid Usage

VUID-VkSemaphoreSignalInfo-semaphore-03257
semaphore must have been created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE
VUID-VkSemaphoreSignalInfo-value-03258
value must have a value greater than the current value of the semaphore
VUID-VkSemaphoreSignalInfo-value-03259
value must be less than the value of any pending semaphore signal operations
VUID-VkSemaphoreSignalInfo-value-03260
value must have a value which does not differ from the current value of the semaphore or the value of any outstanding semaphore wait or signal operation on semaphore by more than maxTimelineSemaphoreValueDifference.

Valid Usage (Implicit)

VUID-VkSemaphoreSignalInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO
VUID-VkSemaphoreSignalInfo-pNext-pNext
pNext must be NULL
VUID-VkSemaphoreSignalInfo-semaphore-parameter
semaphore must be a valid VkSemaphore handle

6.4.5. Importing Semaphore Payloads

Applications can import a semaphore payload into an existing semaphore using an external semaphore handle. The effects of the import operation will be either temporary or permanent, as specified by the application. If the import is temporary, the implementation must restore the semaphore to its prior permanent state after submitting the next semaphore wait operation. Performing a subsequent temporary import on a semaphore before performing a semaphore wait has no effect on this requirement; the next wait submitted on the semaphore must still restore its last permanent state. A permanent payload import behaves as if the target semaphore was destroyed, and a new semaphore was created with the same handle but the imported payload. Because importing a semaphore payload temporarily or permanently detaches the existing payload from a semaphore, similar usage restrictions to those applied to vkDestroySemaphore are applied to any command that imports a semaphore payload. Which of these import types is used is referred to as the import operation’s permanence. Each handle type supports either one or both types of permanence.

The implementation must perform the import operation by either referencing or copying the payload referred to by the specified external semaphore handle, depending on the handle’s type. The import method used is referred to as the handle type’s transference. When using handle types with reference transference, importing a payload to a semaphore adds the semaphore to the set of all semaphores sharing that payload. This set includes the semaphore from which the payload was exported. Semaphore signaling and waiting operations performed on any semaphore in the set must behave as if the set were a single semaphore. Importing a payload using handle types with copy transference creates a duplicate copy of the payload at the time of import, but makes no further reference to it. Semaphore signaling and waiting operations performed on the target of copy imports must not affect any other semaphore or payload.

Export operations have the same transference as the specified handle type’s import operations. Additionally, exporting a semaphore payload to a handle with copy transference has the same side effects on the source semaphore’s payload as executing a semaphore wait operation. If the semaphore was using a temporarily imported payload, the semaphore’s prior permanent payload will be restored.

Note

The tables Handle Types Supported by VkImportSemaphoreWin32HandleInfoKHR and Handle Types Supported by VkImportSemaphoreFdInfoKHR define the permanence and transference of each handle type.

External synchronization allows implementations to modify an object’s internal state, i.e. payload, without internal synchronization. However, for semaphores sharing a payload across processes, satisfying the external synchronization requirements of VkSemaphore parameters as if all semaphores in the set were the same object is sometimes infeasible. Satisfying the wait operation state requirements would similarly require impractical coordination or levels of trust between processes. Therefore, these constraints only apply to a specific semaphore handle, not to its payload. For distinct semaphore objects which share a payload, if the semaphores are passed to separate queue submission commands concurrently, behavior will be as if the commands were called in an arbitrary sequential order. If the wait operation state requirements are violated for the shared payload by a queue submission command, or if a signal operation is queued for a shared payload that is already signaled or has a pending signal operation, effects must be limited to one or more of the following:

Returning VK_ERROR_INITIALIZATION_FAILED from the command which resulted in the violation.
Losing the logical device on which the violation occurred immediately or at a future time, resulting in a VK_ERROR_DEVICE_LOST error from subsequent commands, including the one causing the violation.
Continuing execution of the violating command or operation as if the semaphore wait completed successfully after an implementation-dependent timeout. In this case, the state of the payload becomes undefined, and future operations on semaphores sharing the payload will be subject to these same rules. The semaphore must be destroyed or have its payload replaced by an import operation to again have a well-defined state.

Note

These rules allow processes to synchronize access to shared memory without trusting each other. However, such processes must still be cautious not to use the shared semaphore for more than synchronizing access to the shared memory. For example, a process should not use a shared semaphore as part of an execution dependency chain that, when complete, leads to objects being destroyed, if it does not trust other processes sharing the semaphore payload.

When a semaphore is using an imported payload, its VkExportSemaphoreCreateInfo::handleTypes value is that specified when creating the semaphore from which the payload was exported, rather than that specified when creating the semaphore. Additionally, VkExternalSemaphoreProperties::exportFromImportedHandleTypes restricts which handle types can be exported from such a semaphore based on the specific handle type used to import the current payload. Passing a semaphore to vkAcquireNextImageKHR is equivalent to temporarily importing a semaphore payload to that semaphore.

Note

Because the exportable handle types of an imported semaphore correspond to its current imported payload, and vkAcquireNextImageKHR behaves the same as a temporary import operation for which the source semaphore is opaque to the application, applications have no way of determining whether any external handle types can be exported from a semaphore in this state. Therefore, applications must not attempt to export external handles from semaphores using a temporarily imported payload from vkAcquireNextImageKHR.

When importing a semaphore payload, it is the responsibility of the application to ensure the external handles meet all valid usage requirements. However, implementations must perform sufficient validation of external handles to ensure that the operation results in a valid semaphore which will not cause program termination, device loss, queue stalls, or corruption of other resources when used as allowed according to its import parameters, and excepting those side effects allowed for violations of the valid semaphore state for wait operations rules. If the external handle provided does not meet these requirements, the implementation must fail the semaphore payload import operation with the error code VK_ERROR_INVALID_EXTERNAL_HANDLE.

In addition, when importing a semaphore payload that is not compatible with the payload type corresponding to the VkSemaphoreType the semaphore was created with, the implementation may fail the semaphore payload import operation with the error code VK_ERROR_INVALID_EXTERNAL_HANDLE.

Note

To import a semaphore payload from a Windows handle, call:

VkResult vkImportSemaphoreWin32HandleKHR(
    VkDevice                                    device,
    const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);

device is the logical device that created the semaphore.
pImportSemaphoreWin32HandleInfo is a pointer to a VkImportSemaphoreWin32HandleInfoKHR structure specifying the semaphore and import parameters.

Importing a semaphore payload from Windows handles does not transfer ownership of the handle to the Vulkan implementation. For handle types defined as NT handles, the application must release ownership using the CloseHandle system call when the handle is no longer needed.

Applications can import the same semaphore payload into multiple instances of Vulkan, into the same instance from which it was exported, and multiple times into a given Vulkan instance.

Valid Usage (Implicit)

VUID-vkImportSemaphoreWin32HandleKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkImportSemaphoreWin32HandleKHR-pImportSemaphoreWin32HandleInfo-parameter
pImportSemaphoreWin32HandleInfo must be a valid pointer to a valid VkImportSemaphoreWin32HandleInfoKHR structure

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_INVALID_EXTERNAL_HANDLE

The VkImportSemaphoreWin32HandleInfoKHR structure is defined as:

typedef struct VkImportSemaphoreWin32HandleInfoKHR {
    VkStructureType                          sType;
    const void*                              pNext;
    VkSemaphore                              semaphore;
    VkSemaphoreImportFlags                   flags;
    VkExternalSemaphoreHandleTypeFlagBits    handleType;
    HANDLE                                   handle;
    LPCWSTR                                  name;
} VkImportSemaphoreWin32HandleInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
semaphore is the semaphore into which the payload will be imported.
flags is a bitmask of VkSemaphoreImportFlagBits specifying additional parameters for the semaphore payload import operation.
handleType specifies the type of handle.
handle is the external handle to import, or NULL.
name is a null-terminated UTF-16 string naming the underlying synchronization primitive to import, or NULL.

The handle types supported by handleType are:

Table 8. Handle Types Supported by VkImportSemaphoreWin32HandleInfoKHR
Handle Type	Transference	Permanence Supported
`VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT`	Reference	Temporary,Permanent
`VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT`	Reference	Temporary,Permanent
`VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT`	Reference	Temporary,Permanent

Valid Usage

VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01140
handleType must be a value included in the Handle Types Supported by VkImportSemaphoreWin32HandleInfoKHR table.
VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01466
If handleType is not VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, name must be NULL.
VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01467
If handleType is not 0 and handle is NULL, name must name a valid synchronization primitive of the type specified by handleType.
VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01468
If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType.
VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01469
If handle is not NULL, name must be NULL.
VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01542
If handle is not NULL, it must obey any requirements listed for handleType in external semaphore handle types compatibility.
VUID-VkImportSemaphoreWin32HandleInfoKHR-name-01543
If name is not NULL, it must obey any requirements listed for handleType in external semaphore handle types compatibility.
VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-03261
If handleType is VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, the VkSemaphoreCreateInfo::flags field must match that of the semaphore from which handle or name was exported.
VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-03262
If handleType is VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, the VkSemaphoreTypeCreateInfo::semaphoreType field must match that of the semaphore from which handle or name was exported.
VUID-VkImportSemaphoreWin32HandleInfoKHR-flags-03322
If flags contains VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, the VkSemaphoreTypeCreateInfo::semaphoreType field of the semaphore from which handle or name was exported must not be VK_SEMAPHORE_TYPE_TIMELINE.

Valid Usage (Implicit)

VUID-VkImportSemaphoreWin32HandleInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR
VUID-VkImportSemaphoreWin32HandleInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkImportSemaphoreWin32HandleInfoKHR-semaphore-parameter
semaphore must be a valid VkSemaphore handle
VUID-VkImportSemaphoreWin32HandleInfoKHR-flags-parameter
flags must be a valid combination of VkSemaphoreImportFlagBits values
VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-parameter
If handleType is not 0, handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value

Host Synchronization

Host access to semaphore must be externally synchronized

To import a semaphore payload from a POSIX file descriptor, call:

VkResult vkImportSemaphoreFdKHR(
    VkDevice                                    device,
    const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo);

device is the logical device that created the semaphore.
pImportSemaphoreFdInfo is a pointer to a VkImportSemaphoreFdInfoKHR structure specifying the semaphore and import parameters.

Importing a semaphore payload from a file descriptor transfers ownership of the file descriptor from the application to the Vulkan implementation. The application must not perform any operations on the file descriptor after a successful import.

Applications can import the same semaphore payload into multiple instances of Vulkan, into the same instance from which it was exported, and multiple times into a given Vulkan instance.

Valid Usage

VUID-vkImportSemaphoreFdKHR-semaphore-01142
semaphore must not be associated with any queue command that has not yet completed execution on that queue

Valid Usage (Implicit)

VUID-vkImportSemaphoreFdKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkImportSemaphoreFdKHR-pImportSemaphoreFdInfo-parameter
pImportSemaphoreFdInfo must be a valid pointer to a valid VkImportSemaphoreFdInfoKHR structure

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_INVALID_EXTERNAL_HANDLE

The VkImportSemaphoreFdInfoKHR structure is defined as:

typedef struct VkImportSemaphoreFdInfoKHR {
    VkStructureType                          sType;
    const void*                              pNext;
    VkSemaphore                              semaphore;
    VkSemaphoreImportFlags                   flags;
    VkExternalSemaphoreHandleTypeFlagBits    handleType;
    int                                      fd;
} VkImportSemaphoreFdInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
semaphore is the semaphore into which the payload will be imported.
flags is a bitmask of VkSemaphoreImportFlagBits specifying additional parameters for the semaphore payload import operation.
handleType specifies the type of fd.
fd is the external handle to import.

The handle types supported by handleType are:

Table 9. Handle Types Supported by VkImportSemaphoreFdInfoKHR
Handle Type	Transference	Permanence Supported
`VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT`	Reference	Temporary,Permanent
`VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT`	Copy	Temporary

Valid Usage

VUID-VkImportSemaphoreFdInfoKHR-handleType-01143
handleType must be a value included in the Handle Types Supported by VkImportSemaphoreFdInfoKHR table.
VUID-VkImportSemaphoreFdInfoKHR-fd-01544
fd must obey any requirements listed for handleType in external semaphore handle types compatibility.
VUID-VkImportSemaphoreFdInfoKHR-handleType-03263
If handleType is VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, the VkSemaphoreCreateInfo::flags field must match that of the semaphore from which fd was exported.
VUID-VkImportSemaphoreFdInfoKHR-handleType-03264
If handleType is VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, the VkSemaphoreTypeCreateInfo::semaphoreType field must match that of the semaphore from which fd was exported.
VUID-VkImportSemaphoreFdInfoKHR-flags-03323
If flags contains VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, the VkSemaphoreTypeCreateInfo::semaphoreType field of the semaphore from which fd was exported must not be VK_SEMAPHORE_TYPE_TIMELINE.

Valid Usage (Implicit)

VUID-VkImportSemaphoreFdInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR
VUID-VkImportSemaphoreFdInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkImportSemaphoreFdInfoKHR-semaphore-parameter
semaphore must be a valid VkSemaphore handle
VUID-VkImportSemaphoreFdInfoKHR-flags-parameter
flags must be a valid combination of VkSemaphoreImportFlagBits values
VUID-VkImportSemaphoreFdInfoKHR-handleType-parameter
handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value

Host Synchronization

Host access to semaphore must be externally synchronized

Additional parameters of a semaphore import operation are specified by VkImportSemaphoreWin32HandleInfoKHR::flags or VkImportSemaphoreFdInfoKHR::flags . Bits which can be set include:

typedef enum VkSemaphoreImportFlagBits {
    VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001,
    VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
    VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkSemaphoreImportFlagBits;

or the equivalent

typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR;

These bits have the following meanings:

VK_SEMAPHORE_IMPORT_TEMPORARY_BIT specifies that the semaphore payload will be imported only temporarily, as described in Importing Semaphore Payloads, regardless of the permanence of handleType.

typedef VkFlags VkSemaphoreImportFlags;

or the equivalent

typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR;

VkSemaphoreImportFlags is a bitmask type for setting a mask of zero or more VkSemaphoreImportFlagBits.

6.5. Events

Events are a synchronization primitive that can be used to insert a fine-grained dependency between commands submitted to the same queue, or between the host and a queue. Events must not be used to insert a dependency between commands submitted to different queues. Events have two states - signaled and unsignaled. An application can signal an event, or unsignal it, on either the host or the device. A device can wait for an event to become signaled before executing further operations. No command exists to wait for an event to become signaled on the host, but the current state of an event can be queried.

Events are represented by VkEvent handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)

To create an event, call:

VkResult vkCreateEvent(
    VkDevice                                    device,
    const VkEventCreateInfo*                    pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkEvent*                                    pEvent);

device is the logical device that creates the event.
pCreateInfo is a pointer to a VkEventCreateInfo structure containing information about how the event is to be created.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pEvent is a pointer to a handle in which the resulting event object is returned.

When created, the event object is in the unsignaled state.

Valid Usage (Implicit)

VUID-vkCreateEvent-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateEvent-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkEventCreateInfo structure
VUID-vkCreateEvent-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateEvent-pEvent-parameter
pEvent must be a valid pointer to a VkEvent handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkEventCreateInfo structure is defined as:

typedef struct VkEventCreateInfo {
    VkStructureType       sType;
    const void*           pNext;
    VkEventCreateFlags    flags;
} VkEventCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.

Valid Usage (Implicit)

VUID-VkEventCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO
VUID-VkEventCreateInfo-pNext-pNext
pNext must be NULL
VUID-VkEventCreateInfo-flags-zerobitmask
flags must be 0

typedef VkFlags VkEventCreateFlags;

VkEventCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

To destroy an event, call:

void vkDestroyEvent(
    VkDevice                                    device,
    VkEvent                                     event,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the event.
event is the handle of the event to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyEvent-event-01145
All submitted commands that refer to event must have completed execution
VUID-vkDestroyEvent-event-01146
If VkAllocationCallbacks were provided when event was created, a compatible set of callbacks must be provided here
VUID-vkDestroyEvent-event-01147
If no VkAllocationCallbacks were provided when event was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyEvent-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyEvent-event-parameter
If event is not VK_NULL_HANDLE, event must be a valid VkEvent handle
VUID-vkDestroyEvent-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyEvent-event-parent
If event is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to event must be externally synchronized

To query the state of an event from the host, call:

VkResult vkGetEventStatus(
    VkDevice                                    device,
    VkEvent                                     event);

device is the logical device that owns the event.
event is the handle of the event to query.

Upon success, vkGetEventStatus returns the state of the event object with the following return codes:

Table 10. Event Object Status Codes
Status	Meaning
`VK_EVENT_SET`	The event specified by `event` is signaled.
`VK_EVENT_RESET`	The event specified by `event` is unsignaled.

If a vkCmdSetEvent or vkCmdResetEvent command is in a command buffer that is in the pending state, then the value returned by this command may immediately be out of date.

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 (Implicit)

VUID-vkGetEventStatus-device-parameter
device must be a valid VkDevice handle
VUID-vkGetEventStatus-event-parameter
event must be a valid VkEvent handle
VUID-vkGetEventStatus-event-parent
event must have been created, allocated, or retrieved from device

Return Codes

VK_EVENT_SET
VK_EVENT_RESET

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST

To set the state of an event to signaled from the host, call:

VkResult vkSetEvent(
    VkDevice                                    device,
    VkEvent                                     event);

device is the logical device that owns the event.
event is the event to set.

When vkSetEvent is executed on the host, it defines an event signal operation which sets the event to the signaled state.

If event is already in the signaled state when vkSetEvent is executed, then vkSetEvent has no effect, and no event signal operation occurs.

Valid Usage (Implicit)

VUID-vkSetEvent-device-parameter
device must be a valid VkDevice handle
VUID-vkSetEvent-event-parameter
event must be a valid VkEvent handle
VUID-vkSetEvent-event-parent
event must have been created, allocated, or retrieved from device

Host Synchronization

Host access to event must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

To set the state of an event to unsignaled from the host, call:

VkResult vkResetEvent(
    VkDevice                                    device,
    VkEvent                                     event);

device is the logical device that owns the event.
event is the event to reset.

When vkResetEvent is executed on the host, it defines an event unsignal operation which resets the event to the unsignaled state.

If event is already in the unsignaled state when vkResetEvent is executed, then vkResetEvent has no effect, and no event unsignal operation occurs.

Valid Usage

VUID-vkResetEvent-event-01148
event must not be waited on by a vkCmdWaitEvents command that is currently executing

Valid Usage (Implicit)

VUID-vkResetEvent-device-parameter
device must be a valid VkDevice handle
VUID-vkResetEvent-event-parameter
event must be a valid VkEvent handle
VUID-vkResetEvent-event-parent
event must have been created, allocated, or retrieved from device

Host Synchronization

Host access to event must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The state of an event can also be updated on the device by commands inserted in command buffers.

To set the state of an event to signaled from a device, call:

void vkCmdSetEvent(
    VkCommandBuffer                             commandBuffer,
    VkEvent                                     event,
    VkPipelineStageFlags                        stageMask);

commandBuffer is the command buffer into which the command is recorded.
event is the event that will be signaled.
stageMask specifies the source stage mask used to determine when the event is signaled.

When vkCmdSetEvent is submitted to a queue, it defines an execution dependency on commands that were submitted before it, and defines an event signal operation which sets the event to the signaled state.

The first synchronization scope includes all commands that occur earlier in submission order. The synchronization scope is limited to operations on the pipeline stages determined by the source stage mask specified by stageMask.

The second synchronization scope includes only the event signal operation.

If event is already in the signaled state when vkCmdSetEvent is executed on the device, then vkCmdSetEvent has no effect, no event signal operation occurs, and no execution dependency is generated.

Valid Usage

VUID-vkCmdSetEvent-stageMask-01149
stageMask must not include VK_PIPELINE_STAGE_HOST_BIT
VUID-vkCmdSetEvent-stageMask-01150
If the geometry shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
VUID-vkCmdSetEvent-stageMask-01151
If the tessellation shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
VUID-vkCmdSetEvent-commandBuffer-01152
commandBuffer’s current device mask must include exactly one physical device.
VUID-vkCmdSetEvent-stageMask-02107
If the mesh shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV
VUID-vkCmdSetEvent-stageMask-02108
If the task shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV

Valid Usage (Implicit)

VUID-vkCmdSetEvent-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetEvent-event-parameter
event must be a valid VkEvent handle
VUID-vkCmdSetEvent-stageMask-parameter
stageMask must be a valid combination of VkPipelineStageFlagBits values
VUID-vkCmdSetEvent-stageMask-requiredbitmask
stageMask must not be 0
VUID-vkCmdSetEvent-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetEvent-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
VUID-vkCmdSetEvent-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdSetEvent-commonparent
Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Graphics
Compute

To set the state of an event to unsignaled from a device, call:

void vkCmdResetEvent(
    VkCommandBuffer                             commandBuffer,
    VkEvent                                     event,
    VkPipelineStageFlags                        stageMask);

commandBuffer is the command buffer into which the command is recorded.
event is the event that will be unsignaled.
stageMask is a bitmask of VkPipelineStageFlagBits specifying the source stage mask used to determine when the event is unsignaled.

When vkCmdResetEvent is submitted to a queue, it defines an execution dependency on commands that were submitted before it, and defines an event unsignal operation which resets the event to the unsignaled state.

The second synchronization scope includes only the event unsignal operation.

If event is already in the unsignaled state when vkCmdResetEvent is executed on the device, then vkCmdResetEvent has no effect, no event unsignal operation occurs, and no execution dependency is generated.

Valid Usage

VUID-vkCmdResetEvent-stageMask-01153
stageMask must not include VK_PIPELINE_STAGE_HOST_BIT
VUID-vkCmdResetEvent-stageMask-01154
If the geometry shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
VUID-vkCmdResetEvent-stageMask-01155
If the tessellation shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
VUID-vkCmdResetEvent-event-01156
When this command executes, event must not be waited on by a vkCmdWaitEvents command that is currently executing
VUID-vkCmdResetEvent-commandBuffer-01157
commandBuffer’s current device mask must include exactly one physical device.
VUID-vkCmdResetEvent-stageMask-02109
If the mesh shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV
VUID-vkCmdResetEvent-stageMask-02110
If the task shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV

Valid Usage (Implicit)

VUID-vkCmdResetEvent-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdResetEvent-event-parameter
event must be a valid VkEvent handle
VUID-vkCmdResetEvent-stageMask-parameter
stageMask must be a valid combination of VkPipelineStageFlagBits values
VUID-vkCmdResetEvent-stageMask-requiredbitmask
stageMask must not be 0
VUID-vkCmdResetEvent-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdResetEvent-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
VUID-vkCmdResetEvent-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdResetEvent-commonparent
Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Graphics
Compute

To wait for one or more events to enter the signaled state on a device, call:

void vkCmdWaitEvents(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    eventCount,
    const VkEvent*                              pEvents,
    VkPipelineStageFlags                        srcStageMask,
    VkPipelineStageFlags                        dstStageMask,
    uint32_t                                    memoryBarrierCount,
    const VkMemoryBarrier*                      pMemoryBarriers,
    uint32_t                                    bufferMemoryBarrierCount,
    const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
    uint32_t                                    imageMemoryBarrierCount,
    const VkImageMemoryBarrier*                 pImageMemoryBarriers);

commandBuffer is the command buffer into which the command is recorded.
eventCount is the length of the pEvents array.
pEvents is a pointer to an array of event object handles to wait on.
srcStageMask is a bitmask of VkPipelineStageFlagBits specifying the source stage mask.
dstStageMask is a bitmask of VkPipelineStageFlagBits specifying the destination stage mask.
memoryBarrierCount is the length of the pMemoryBarriers array.
pMemoryBarriers is a pointer to an array of VkMemoryBarrier structures.
bufferMemoryBarrierCount is the length of the pBufferMemoryBarriers array.
pBufferMemoryBarriers is a pointer to an array of VkBufferMemoryBarrier structures.
imageMemoryBarrierCount is the length of the pImageMemoryBarriers array.
pImageMemoryBarriers is a pointer to an array of VkImageMemoryBarrier structures.

When vkCmdWaitEvents is submitted to a queue, it defines a memory dependency between prior event signal operations on the same queue or the host, and subsequent commands. vkCmdWaitEvents must not be used to wait on event signal operations occurring on other queues.

The first synchronization scope only includes event signal operations that operate on members of pEvents, and the operations that happened-before the event signal operations. Event signal operations performed by vkCmdSetEvent that occur earlier in submission order are included in the first synchronization scope, if the logically latest pipeline stage in their stageMask parameter is logically earlier than or equal to the logically latest pipeline stage in srcStageMask. Event signal operations performed by vkSetEvent are only included in the first synchronization scope if VK_PIPELINE_STAGE_HOST_BIT is included in srcStageMask.

The second synchronization scope includes all commands that occur later in submission order. The second synchronization scope is limited to operations on the pipeline stages determined by the destination stage mask specified by dstStageMask.

The first access scope is limited to access in the pipeline stages determined by the source stage mask specified by srcStageMask. Within that, the first access scope only includes the first access scopes defined by elements of the pMemoryBarriers, pBufferMemoryBarriers and pImageMemoryBarriers arrays, which each define a set of memory barriers. If no memory barriers are specified, then the first access scope includes no accesses.

The second access scope is limited to access in the pipeline stages determined by the destination stage mask specified by dstStageMask. Within that, the second access scope only includes the second access scopes defined by elements of the pMemoryBarriers, pBufferMemoryBarriers and pImageMemoryBarriers arrays, which each define a set of memory barriers. If no memory barriers are specified, then the second access scope includes no accesses.

Note

vkCmdWaitEvents is used with vkCmdSetEvent to define a memory dependency between two sets of action commands, roughly in the same way as pipeline barriers, but split into two commands such that work between the two may execute unhindered.

Unlike vkCmdPipelineBarrier, a queue family ownership transfer cannot be performed using vkCmdWaitEvents.

Note

Applications should be careful to avoid race conditions when using events. There is no direct ordering guarantee between a vkCmdResetEvent command and a vkCmdWaitEvents command submitted after it, so some other execution dependency must be included between these commands (e.g. a semaphore).

Valid Usage

VUID-vkCmdWaitEvents-srcStageMask-01158
srcStageMask must be the bitwise OR of the stageMask parameter used in previous calls to vkCmdSetEvent with any of the members of pEvents and VK_PIPELINE_STAGE_HOST_BIT if any of the members of pEvents was set using vkSetEvent
VUID-vkCmdWaitEvents-srcStageMask-01159
If the geometry shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
VUID-vkCmdWaitEvents-dstStageMask-01160
If the geometry shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
VUID-vkCmdWaitEvents-srcStageMask-01161
If the tessellation shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
VUID-vkCmdWaitEvents-dstStageMask-01162
If the tessellation shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
VUID-vkCmdWaitEvents-pEvents-01163
If pEvents includes one or more events that will be signaled by vkSetEvent after commandBuffer has been submitted to a queue, then vkCmdWaitEvents must not be called inside a render pass instance
VUID-vkCmdWaitEvents-srcStageMask-01164
Any pipeline stage included in srcStageMask or dstStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the table of supported pipeline stages.
VUID-vkCmdWaitEvents-pMemoryBarriers-01165
Each element of pMemoryBarriers, pBufferMemoryBarriers or pImageMemoryBarriers must not have any access flag included in its srcAccessMask member if that bit is not supported by any of the pipeline stages in srcStageMask, as specified in the table of supported access types.
VUID-vkCmdWaitEvents-pMemoryBarriers-01166
Each element of pMemoryBarriers, pBufferMemoryBarriers or pImageMemoryBarriers must not have any access flag included in its dstAccessMask member if that bit is not supported by any of the pipeline stages in dstStageMask, as specified in the table of supported access types.
VUID-vkCmdWaitEvents-srcQueueFamilyIndex-02803
The srcQueueFamilyIndex and dstQueueFamilyIndex members of any element of pBufferMemoryBarriers or pImageMemoryBarriers must be equal.
VUID-vkCmdWaitEvents-commandBuffer-01167
commandBuffer’s current device mask must include exactly one physical device.
VUID-vkCmdWaitEvents-srcStageMask-02111
If the mesh shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV
VUID-vkCmdWaitEvents-srcStageMask-02112
If the task shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV
VUID-vkCmdWaitEvents-dstStageMask-02113
If the mesh shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV
VUID-vkCmdWaitEvents-dstStageMask-02114
If the task shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV
VUID-vkCmdWaitEvents-srcAccessMask-02809
The srcAccessMask member of each element of pMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types
VUID-vkCmdWaitEvents-dstAccessMask-02810
The dstAccessMask member of each element of pMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types
VUID-vkCmdWaitEvents-srcAccessMask-02811
The srcAccessMask member of each element of pBufferMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types
VUID-vkCmdWaitEvents-dstAccessMask-02812
The dstAccessMask member of each element of pBufferMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types
VUID-vkCmdWaitEvents-srcAccessMask-02813
The srcAccessMask member of each element of pImageMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types
VUID-vkCmdWaitEvents-dstAccessMask-02814
The dstAccessMask member of any element of pImageMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types

Valid Usage (Implicit)

VUID-vkCmdWaitEvents-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdWaitEvents-pEvents-parameter
pEvents must be a valid pointer to an array of eventCount valid VkEvent handles
VUID-vkCmdWaitEvents-srcStageMask-parameter
srcStageMask must be a valid combination of VkPipelineStageFlagBits values
VUID-vkCmdWaitEvents-srcStageMask-requiredbitmask
srcStageMask must not be 0
VUID-vkCmdWaitEvents-dstStageMask-parameter
dstStageMask must be a valid combination of VkPipelineStageFlagBits values
VUID-vkCmdWaitEvents-dstStageMask-requiredbitmask
dstStageMask must not be 0
VUID-vkCmdWaitEvents-pMemoryBarriers-parameter
If memoryBarrierCount is not 0, pMemoryBarriers must be a valid pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures
VUID-vkCmdWaitEvents-pBufferMemoryBarriers-parameter
If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a valid pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures
VUID-vkCmdWaitEvents-pImageMemoryBarriers-parameter
If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a valid pointer to an array of imageMemoryBarrierCount valid VkImageMemoryBarrier structures
VUID-vkCmdWaitEvents-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdWaitEvents-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
VUID-vkCmdWaitEvents-eventCount-arraylength
eventCount must be greater than 0
VUID-vkCmdWaitEvents-commonparent
Both of commandBuffer, and the elements of pEvents must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

6.6. Pipeline Barriers

vkCmdPipelineBarrier is a synchronization command that inserts a dependency between commands submitted to the same queue, or between commands in the same subpass.

To record a pipeline barrier, call:

void vkCmdPipelineBarrier(
    VkCommandBuffer                             commandBuffer,
    VkPipelineStageFlags                        srcStageMask,
    VkPipelineStageFlags                        dstStageMask,
    VkDependencyFlags                           dependencyFlags,
    uint32_t                                    memoryBarrierCount,
    const VkMemoryBarrier*                      pMemoryBarriers,
    uint32_t                                    bufferMemoryBarrierCount,
    const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
    uint32_t                                    imageMemoryBarrierCount,
    const VkImageMemoryBarrier*                 pImageMemoryBarriers);

commandBuffer is the command buffer into which the command is recorded.
srcStageMask is a bitmask of VkPipelineStageFlagBits specifying the source stage mask.
dstStageMask is a bitmask of VkPipelineStageFlagBits specifying the destination stage mask.
dependencyFlags is a bitmask of VkDependencyFlagBits specifying how execution and memory dependencies are formed.
memoryBarrierCount is the length of the pMemoryBarriers array.
pMemoryBarriers is a pointer to an array of VkMemoryBarrier structures.
bufferMemoryBarrierCount is the length of the pBufferMemoryBarriers array.
pBufferMemoryBarriers is a pointer to an array of VkBufferMemoryBarrier structures.
imageMemoryBarrierCount is the length of the pImageMemoryBarriers array.
pImageMemoryBarriers is a pointer to an array of VkImageMemoryBarrier structures.

When vkCmdPipelineBarrier is submitted to a queue, it defines a memory dependency between commands that were submitted before it, and those submitted after it.

If vkCmdPipelineBarrier was recorded outside a render pass instance, the first synchronization scope includes all commands that occur earlier in submission order. If vkCmdPipelineBarrier was recorded inside a render pass instance, the first synchronization scope includes only commands that occur earlier in submission order within the same subpass. In either case, the first synchronization scope is limited to operations on the pipeline stages determined by the source stage mask specified by srcStageMask.

If vkCmdPipelineBarrier was recorded outside a render pass instance, the second synchronization scope includes all commands that occur later in submission order. If vkCmdPipelineBarrier was recorded inside a render pass instance, the second synchronization scope includes only commands that occur later in submission order within the same subpass. In either case, the second synchronization scope is limited to operations on the pipeline stages determined by the destination stage mask specified by dstStageMask.

If dependencyFlags includes VK_DEPENDENCY_BY_REGION_BIT, then any dependency between framebuffer-space pipeline stages is framebuffer-local - otherwise it is framebuffer-global.

Valid Usage

VUID-vkCmdPipelineBarrier-srcStageMask-01168
If the geometry shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
VUID-vkCmdPipelineBarrier-dstStageMask-01169
If the geometry shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
VUID-vkCmdPipelineBarrier-srcStageMask-01170
If the tessellation shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
VUID-vkCmdPipelineBarrier-dstStageMask-01171
If the tessellation shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
VUID-vkCmdPipelineBarrier-pDependencies-02285
If vkCmdPipelineBarrier is called within a render pass instance, the render pass must have been created with at least one VkSubpassDependency instance in VkRenderPassCreateInfo::pDependencies that expresses a dependency from the current subpass to itself, and for which srcStageMask contains a subset of the bit values in VkSubpassDependency::srcStageMask, dstStageMask contains a subset of the bit values in VkSubpassDependency::dstStageMask, dependencyFlags is equal to VkSubpassDependency::dependencyFlags, srcAccessMask member of each element of pMemoryBarriers and pImageMemoryBarriers contains a subset of the bit values in VkSubpassDependency::srcAccessMask, and dstAccessMask member of each element of pMemoryBarriers and pImageMemoryBarriers contains a subset of the bit values in VkSubpassDependency::dstAccessMask
VUID-vkCmdPipelineBarrier-bufferMemoryBarrierCount-01178
If vkCmdPipelineBarrier is called within a render pass instance, bufferMemoryBarrierCount must be 0
VUID-vkCmdPipelineBarrier-image-02635
If vkCmdPipelineBarrier is called within a render pass instance, the image member of any element of pImageMemoryBarriers must be equal to one of the elements of pAttachments that the current framebuffer was created with, that is also referred to by one of the elements of the pColorAttachments, pResolveAttachments or pDepthStencilAttachment members of the VkSubpassDescription instance or by the pDepthStencilResolveAttachment member of the VkSubpassDescriptionDepthStencilResolve structure that the current subpass was created with
VUID-vkCmdPipelineBarrier-oldLayout-02636
If vkCmdPipelineBarrier is called within a render pass instance, the oldLayout and newLayout members of any element of pImageMemoryBarriers must be equal to the layout member of an element of the pColorAttachments, pResolveAttachments or pDepthStencilAttachment members of the VkSubpassDescription instance or by the pDepthStencilResolveAttachment member of the VkSubpassDescriptionDepthStencilResolve structure that the current subpass was created with, that refers to the same image
VUID-vkCmdPipelineBarrier-oldLayout-01181
If vkCmdPipelineBarrier is called within a render pass instance, the oldLayout and newLayout members of an element of pImageMemoryBarriers must be equal
VUID-vkCmdPipelineBarrier-srcQueueFamilyIndex-01182
If vkCmdPipelineBarrier is called within a render pass instance, the srcQueueFamilyIndex and dstQueueFamilyIndex members of any element of pImageMemoryBarriers must be VK_QUEUE_FAMILY_IGNORED
VUID-vkCmdPipelineBarrier-srcStageMask-01183
Any pipeline stage included in srcStageMask or dstStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the table of supported pipeline stages
VUID-vkCmdPipelineBarrier-dependencyFlags-01186
If vkCmdPipelineBarrier is called outside of a render pass instance, dependencyFlags must not include VK_DEPENDENCY_VIEW_LOCAL_BIT
VUID-vkCmdPipelineBarrier-srcStageMask-02115
If the mesh shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV
VUID-vkCmdPipelineBarrier-srcStageMask-02116
If the task shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV
VUID-vkCmdPipelineBarrier-dstStageMask-02117
If the mesh shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV
VUID-vkCmdPipelineBarrier-dstStageMask-02118
If the task shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV
VUID-vkCmdPipelineBarrier-srcAccessMask-02815
The srcAccessMask member of each element of pMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types
VUID-vkCmdPipelineBarrier-dstAccessMask-02816
The dstAccessMask member of each element of pMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types
VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-02817
For any element of pBufferMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its srcQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its srcAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types
VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-02818
For any element of pBufferMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its dstQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its dstAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types
VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-02819
For any element of pImageMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its srcQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its srcAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types
VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-02820
For any element of pImageMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its dstQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its dstAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types

Valid Usage (Implicit)

VUID-vkCmdPipelineBarrier-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdPipelineBarrier-srcStageMask-parameter
srcStageMask must be a valid combination of VkPipelineStageFlagBits values
VUID-vkCmdPipelineBarrier-srcStageMask-requiredbitmask
srcStageMask must not be 0
VUID-vkCmdPipelineBarrier-dstStageMask-parameter
dstStageMask must be a valid combination of VkPipelineStageFlagBits values
VUID-vkCmdPipelineBarrier-dstStageMask-requiredbitmask
dstStageMask must not be 0
VUID-vkCmdPipelineBarrier-dependencyFlags-parameter
dependencyFlags must be a valid combination of VkDependencyFlagBits values
VUID-vkCmdPipelineBarrier-pMemoryBarriers-parameter
If memoryBarrierCount is not 0, pMemoryBarriers must be a valid pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures
VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-parameter
If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a valid pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures
VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-parameter
If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a valid pointer to an array of imageMemoryBarrierCount valid VkImageMemoryBarrier structures
VUID-vkCmdPipelineBarrier-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdPipelineBarrier-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Transfer
Graphics
Compute

Bits which can be set in vkCmdPipelineBarrier::dependencyFlags, specifying how execution and memory dependencies are formed, are:

typedef enum VkDependencyFlagBits {
    VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
    VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004,
    VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002,
    VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT,
    VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT,
    VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkDependencyFlagBits;

VK_DEPENDENCY_BY_REGION_BIT specifies that dependencies will be framebuffer-local.
VK_DEPENDENCY_VIEW_LOCAL_BIT specifies that a subpass has more than one view.
VK_DEPENDENCY_DEVICE_GROUP_BIT specifies that dependencies are non-device-local dependency.

typedef VkFlags VkDependencyFlags;

VkDependencyFlags is a bitmask type for setting a mask of zero or more VkDependencyFlagBits.

6.6.1. Subpass Self-dependency

If vkCmdPipelineBarrier is called inside a render pass instance, the following restrictions apply. For a given subpass to allow a pipeline barrier, the render pass must declare a self-dependency from that subpass to itself. That is, there must exist a VkSubpassDependency in the subpass dependency list for the render pass with srcSubpass and dstSubpass equal to that subpass index. More than one self-dependency can be declared for each subpass.

Self-dependencies must only include pipeline stage bits that are graphics stages. If any of the stages in srcStages are framebuffer-space stages, dstStages must only contain framebuffer-space stages. Additionally, srcStages must not contain VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT in a self-dependency.

If the source and destination stage masks both include framebuffer-space stages, then dependencyFlags must include VK_DEPENDENCY_BY_REGION_BIT. If the subpass has more than one view, then dependencyFlags must include VK_DEPENDENCY_VIEW_LOCAL_BIT.

A vkCmdPipelineBarrier command inside a render pass instance must be a subset of one of the self-dependencies of the subpass it is used in, meaning that the stage masks and access masks must each include only a subset of the bits of the corresponding mask in that self-dependency. If the self-dependency has VK_DEPENDENCY_BY_REGION_BIT or VK_DEPENDENCY_VIEW_LOCAL_BIT set, then so must the pipeline barrier. Pipeline barriers within a render pass instance can only be types VkMemoryBarrier or VkImageMemoryBarrier. If a VkImageMemoryBarrier is used, the image and image subresource range specified in the barrier must be a subset of one of the image views used by the framebuffer in the current subpass. Additionally, oldLayout must be equal to newLayout, and both the srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED.

6.7. Memory Barriers

Memory barriers are used to explicitly control access to buffer and image subresource ranges. Memory barriers are used to transfer ownership between queue families, change image layouts, and define availability and visibility operations. They explicitly define the access types and buffer and image subresource ranges that are included in the access scopes of a memory dependency that is created by a synchronization command that includes them.

6.7.1. Global Memory Barriers

Global memory barriers apply to memory accesses involving all memory objects that exist at the time of its execution.

The VkMemoryBarrier structure is defined as:

typedef struct VkMemoryBarrier {
    VkStructureType    sType;
    const void*        pNext;
    VkAccessFlags      srcAccessMask;
    VkAccessFlags      dstAccessMask;
} VkMemoryBarrier;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
srcAccessMask is a bitmask of VkAccessFlagBits specifying a source access mask.
dstAccessMask is a bitmask of VkAccessFlagBits specifying a destination access mask.

The first access scope is limited to access types in the source access mask specified by srcAccessMask.

The second access scope is limited to access types in the destination access mask specified by dstAccessMask.

Valid Usage (Implicit)

VUID-VkMemoryBarrier-sType-sType
sType must be VK_STRUCTURE_TYPE_MEMORY_BARRIER
VUID-VkMemoryBarrier-pNext-pNext
pNext must be NULL
VUID-VkMemoryBarrier-srcAccessMask-parameter
srcAccessMask must be a valid combination of VkAccessFlagBits values
VUID-VkMemoryBarrier-dstAccessMask-parameter
dstAccessMask must be a valid combination of VkAccessFlagBits values

6.7.2. Buffer Memory Barriers

Buffer memory barriers only apply to memory accesses involving a specific buffer range. That is, a memory dependency formed from a buffer memory barrier is scoped to access via the specified buffer range. Buffer memory barriers can also be used to define a queue family ownership transfer for the specified buffer range.

The VkBufferMemoryBarrier structure is defined as:

typedef struct VkBufferMemoryBarrier {
    VkStructureType    sType;
    const void*        pNext;
    VkAccessFlags      srcAccessMask;
    VkAccessFlags      dstAccessMask;
    uint32_t           srcQueueFamilyIndex;
    uint32_t           dstQueueFamilyIndex;
    VkBuffer           buffer;
    VkDeviceSize       offset;
    VkDeviceSize       size;
} VkBufferMemoryBarrier;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
srcAccessMask is a bitmask of VkAccessFlagBits specifying a source access mask.
dstAccessMask is a bitmask of VkAccessFlagBits specifying a destination access mask.
srcQueueFamilyIndex is the source queue family for a queue family ownership transfer.
dstQueueFamilyIndex is the destination queue family for a queue family ownership transfer.
buffer is a handle to the buffer whose backing memory is affected by the barrier.
offset is an offset in bytes into the backing memory for buffer; this is relative to the base offset as bound to the buffer (see vkBindBufferMemory).
size is a size in bytes of the affected area of backing memory for buffer, or VK_WHOLE_SIZE to use the range from offset to the end of the buffer.

The first access scope is limited to access to memory through the specified buffer range, via access types in the source access mask specified by srcAccessMask. If srcAccessMask includes VK_ACCESS_HOST_WRITE_BIT, memory writes performed by that access type are also made visible, as that access type is not performed through a resource.

The second access scope is limited to access to memory through the specified buffer range, via access types in the destination access mask. specified by dstAccessMask. If dstAccessMask includes VK_ACCESS_HOST_WRITE_BIT or VK_ACCESS_HOST_READ_BIT, available memory writes are also made visible to accesses of those types, as those access types are not performed through a resource.

If srcQueueFamilyIndex is not equal to dstQueueFamilyIndex, and srcQueueFamilyIndex is equal to the current queue family, then the memory barrier defines a queue family release operation for the specified buffer range, and the second access scope includes no access, as if dstAccessMask was 0.

If dstQueueFamilyIndex is not equal to srcQueueFamilyIndex, and dstQueueFamilyIndex is equal to the current queue family, then the memory barrier defines a queue family acquire operation for the specified buffer range, and the first access scope includes no access, as if srcAccessMask was 0.

Valid Usage

VUID-VkBufferMemoryBarrier-offset-01187
offset must be less than the size of buffer
VUID-VkBufferMemoryBarrier-size-01188
If size is not equal to VK_WHOLE_SIZE, size must be greater than 0
VUID-VkBufferMemoryBarrier-size-01189
If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to than the size of buffer minus offset
VUID-VkBufferMemoryBarrier-buffer-01191
If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED
VUID-VkBufferMemoryBarrier-buffer-01763
If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or a special queue family reserved for external memory ownership transfers, as described in Queue Family Ownership Transfer.
VUID-VkBufferMemoryBarrier-buffer-01193
If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex must also be VK_QUEUE_FAMILY_IGNORED
VUID-VkBufferMemoryBarrier-buffer-01764
If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in Queue Family Ownership Transfer.
VUID-VkBufferMemoryBarrier-buffer-01765
If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in Queue Family Ownership Transfer.
VUID-VkBufferMemoryBarrier-buffer-01196
If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not VK_QUEUE_FAMILY_IGNORED, at least one of them must be the same as the family of the queue that will execute this barrier
VUID-VkBufferMemoryBarrier-buffer-01931
If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object

Valid Usage (Implicit)

VUID-VkBufferMemoryBarrier-sType-sType
sType must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
VUID-VkBufferMemoryBarrier-pNext-pNext
pNext must be NULL
VUID-VkBufferMemoryBarrier-buffer-parameter
buffer must be a valid VkBuffer handle

6.7.3. Image Memory Barriers

Image memory barriers only apply to memory accesses involving a specific image subresource range. That is, a memory dependency formed from an image memory barrier is scoped to access via the specified image subresource range. Image memory barriers can also be used to define image layout transitions or a queue family ownership transfer for the specified image subresource range.

The VkImageMemoryBarrier structure is defined as:

typedef struct VkImageMemoryBarrier {
    VkStructureType            sType;
    const void*                pNext;
    VkAccessFlags              srcAccessMask;
    VkAccessFlags              dstAccessMask;
    VkImageLayout              oldLayout;
    VkImageLayout              newLayout;
    uint32_t                   srcQueueFamilyIndex;
    uint32_t                   dstQueueFamilyIndex;
    VkImage                    image;
    VkImageSubresourceRange    subresourceRange;
} VkImageMemoryBarrier;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
srcAccessMask is a bitmask of VkAccessFlagBits specifying a source access mask.
dstAccessMask is a bitmask of VkAccessFlagBits specifying a destination access mask.
oldLayout is the old layout in an image layout transition.
newLayout is the new layout in an image layout transition.
srcQueueFamilyIndex is the source queue family for a queue family ownership transfer.
dstQueueFamilyIndex is the destination queue family for a queue family ownership transfer.
image is a handle to the image affected by this barrier.
subresourceRange describes the image subresource range within image that is affected by this barrier.

The first access scope is limited to access to memory through the specified image subresource range, via access types in the source access mask specified by srcAccessMask. If srcAccessMask includes VK_ACCESS_HOST_WRITE_BIT, memory writes performed by that access type are also made visible, as that access type is not performed through a resource.

The second access scope is limited to access to memory through the specified image subresource range, via access types in the destination access mask specified by dstAccessMask. If dstAccessMask includes VK_ACCESS_HOST_WRITE_BIT or VK_ACCESS_HOST_READ_BIT, available memory writes are also made visible to accesses of those types, as those access types are not performed through a resource.

If srcQueueFamilyIndex is not equal to dstQueueFamilyIndex, and srcQueueFamilyIndex is equal to the current queue family, then the memory barrier defines a queue family release operation for the specified image subresource range, and the second access scope includes no access, as if dstAccessMask was 0.

If dstQueueFamilyIndex is not equal to srcQueueFamilyIndex, and dstQueueFamilyIndex is equal to the current queue family, then the memory barrier defines a queue family acquire operation for the specified image subresource range, and the first access scope includes no access, as if srcAccessMask was 0.

If oldLayout is not equal to newLayout, then the memory barrier defines an image layout transition for the specified image subresource range.

Layout transitions that are performed via image memory barriers execute in their entirety in submission order, relative to other image layout transitions submitted to the same queue, including those performed by render passes. In effect there is an implicit execution dependency from each such layout transition to all layout transitions previously submitted to the same queue.

The image layout of each image subresource of a depth/stencil image created with VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT is dependent on the last sample locations used to render to the image subresource as a depth/stencil attachment, thus when the image member of a VkImageMemoryBarrier is an image created with this flag the application can include a VkSampleLocationsInfoEXT structure in the pNext chain of VkImageMemoryBarrier to specify the sample locations to use during the image layout transition.

If the VkSampleLocationsInfoEXT structure included in the pNext chain of VkImageMemoryBarrier does not match the sample location state last used to render to the image subresource range specified by subresourceRange or if no VkSampleLocationsInfoEXT structure is included in the pNext chain of VkImageMemoryBarrier, then the contents of the given image subresource range becomes undefined as if oldLayout would equal VK_IMAGE_LAYOUT_UNDEFINED.

If image has a multi-planar format and the image is disjoint, then including VK_IMAGE_ASPECT_COLOR_BIT in the aspectMask member of subresourceRange is equivalent to including VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, and (for three-plane formats only) VK_IMAGE_ASPECT_PLANE_2_BIT.

Valid Usage

VUID-VkImageMemoryBarrier-oldLayout-01197
oldLayout must be VK_IMAGE_LAYOUT_UNDEFINED or the current layout of the image subresources affected by the barrier
VUID-VkImageMemoryBarrier-newLayout-01198
newLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED
VUID-VkImageMemoryBarrier-image-01381
If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED
VUID-VkImageMemoryBarrier-image-01766
If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or a special queue family reserved for external memory transfers, as described in Queue Family Ownership Transfer.
VUID-VkImageMemoryBarrier-image-01201
If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex must also be VK_QUEUE_FAMILY_IGNORED.
VUID-VkImageMemoryBarrier-image-01767
If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in Queue Family Ownership Transfer.
VUID-VkImageMemoryBarrier-image-01768
If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in Queue Family Ownership Transfer.
VUID-VkImageMemoryBarrier-image-01205
If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not VK_QUEUE_FAMILY_IGNORED, at least one of them must be the same as the family of the queue that will execute this barrier
VUID-VkImageMemoryBarrier-subresourceRange-01486
subresourceRange.baseMipLevel must be less than the mipLevels specified in VkImageCreateInfo when image was created
VUID-VkImageMemoryBarrier-subresourceRange-01724
If subresourceRange.levelCount is not VK_REMAINING_MIP_LEVELS, subresourceRange.baseMipLevel + subresourceRange.levelCount must be less than or equal to the mipLevels specified in VkImageCreateInfo when image was created
VUID-VkImageMemoryBarrier-subresourceRange-01488
subresourceRange.baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created
VUID-VkImageMemoryBarrier-subresourceRange-01725
If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created
VUID-VkImageMemoryBarrier-image-03319
If image has a depth/stencil format with both depth and stencil and the separateDepthStencilLayouts feature is enabled, then the aspectMask member of subresourceRange must include either or both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT
VUID-VkImageMemoryBarrier-image-03320
If image has a depth/stencil format with both depth and stencil and the separateDepthStencilLayouts feature is not enabled, then the aspectMask member of subresourceRange must include both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT
VUID-VkImageMemoryBarrier-image-01671
If image has a single-plane color format or is not disjoint, then the aspectMask member of subresourceRange must be VK_IMAGE_ASPECT_COLOR_BIT
VUID-VkImageMemoryBarrier-image-01672
If image has a multi-planar format and the image is disjoint, then the aspectMask member of subresourceRange must include either at least one of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, and VK_IMAGE_ASPECT_PLANE_2_BIT; or must include VK_IMAGE_ASPECT_COLOR_BIT
VUID-VkImageMemoryBarrier-image-01673
If image has a multi-planar format with only two planes, then the aspectMask member of subresourceRange must not include VK_IMAGE_ASPECT_PLANE_2_BIT
VUID-VkImageMemoryBarrier-oldLayout-01208
If either oldLayout or newLayout is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT set
VUID-VkImageMemoryBarrier-oldLayout-01209
If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set
VUID-VkImageMemoryBarrier-oldLayout-01210
If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set
VUID-VkImageMemoryBarrier-oldLayout-01658
If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set
VUID-VkImageMemoryBarrier-oldLayout-01659
If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set
VUID-VkImageMemoryBarrier-oldLayout-01211
If either oldLayout or newLayout is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set
VUID-VkImageMemoryBarrier-oldLayout-01212
If either oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT set
VUID-VkImageMemoryBarrier-oldLayout-01213
If either oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT set
VUID-VkImageMemoryBarrier-image-01932
If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-VkImageMemoryBarrier-oldLayout-02088
If either oldLayout or newLayout is VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV then image must have been created with VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV set

Valid Usage (Implicit)

VUID-VkImageMemoryBarrier-sType-sType
sType must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
VUID-VkImageMemoryBarrier-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkSampleLocationsInfoEXT
VUID-VkImageMemoryBarrier-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkImageMemoryBarrier-oldLayout-parameter
oldLayout must be a valid VkImageLayout value
VUID-VkImageMemoryBarrier-newLayout-parameter
newLayout must be a valid VkImageLayout value
VUID-VkImageMemoryBarrier-image-parameter
image must be a valid VkImage handle
VUID-VkImageMemoryBarrier-subresourceRange-parameter
subresourceRange must be a valid VkImageSubresourceRange structure

6.7.4. Queue Family Ownership Transfer

Resources created with a VkSharingMode of VK_SHARING_MODE_EXCLUSIVE must have their ownership explicitly transferred from one queue family to another in order to access their content in a well-defined manner on a queue in a different queue family. Resources shared with external APIs or instances using external memory must also explicitly manage ownership transfers between local and external queues (or equivalent constructs in external APIs) regardless of the VkSharingMode specified when creating them. The special queue family index VK_QUEUE_FAMILY_EXTERNAL represents any queue external to the resource’s current Vulkan instance, as long as the queue uses the same underlying physical device or device group and uses the same driver version as the resource’s VkDevice, as indicated by VkPhysicalDeviceIDProperties::deviceUUID and VkPhysicalDeviceIDProperties::driverUUID. The special queue family index VK_QUEUE_FAMILY_FOREIGN_EXT represents any queue external to the resource’s current Vulkan instance, regardless of the queue’s underlying physical device or driver version. This includes, for example, queues for fixed-function image processing devices, media codec devices, and display devices, as well as all queues that use the same underlying physical device (or device group) and driver version as the resource’s VkDevice. If memory dependencies are correctly expressed between uses of such a resource between two queues in different families, but no ownership transfer is defined, the contents of that resource are undefined for any read accesses performed by the second queue family.

Note

If an application does not need the contents of a resource to remain valid when transferring from one queue family to another, then the ownership transfer should be skipped.

Note

Applications should expect transfers to/from VK_QUEUE_FAMILY_FOREIGN_EXT to be more expensive than transfers to/from VK_QUEUE_FAMILY_EXTERNAL_KHR.

A queue family ownership transfer consists of two distinct parts:

Release exclusive ownership from the source queue family
Acquire exclusive ownership for the destination queue family

An application must ensure that these operations occur in the correct order by defining an execution dependency between them, e.g. using a semaphore.

A release operation is used to release exclusive ownership of a range of a buffer or image subresource range. A release operation is defined by executing a buffer memory barrier (for a buffer range) or an image memory barrier (for an image subresource range) using vkCmdPipelineBarrier, on a queue from the source queue family. The srcQueueFamilyIndex parameter of the barrier must be set to the source queue family index, and the dstQueueFamilyIndex parameter to the destination queue family index. dstAccessMask is ignored for such a barrier, such that no visibility operation is executed - the value of this mask does not affect the validity of the barrier. The release operation happens-after the availability operation, and happens-before operations specified in the second synchronization scope of the calling command.

An acquire operation is used to acquire exclusive ownership of a range of a buffer or image subresource range. An acquire operation is defined by executing a buffer memory barrier (for a buffer range) or an image memory barrier (for an image subresource range) using vkCmdPipelineBarrier, on a queue from the destination queue family. The buffer range or image subresource range specified in an acquire operation must match exactly that of a previous release operation. The srcQueueFamilyIndex parameter of the barrier must be set to the source queue family index, and the dstQueueFamilyIndex parameter to the destination queue family index. srcAccessMask is ignored for such a barrier, such that no availability operation is executed - the value of this mask does not affect the validity of the barrier. The acquire operation happens-after operations in the first synchronization scope of the calling command, and happens-before the visibility operation.

Note

Whilst it is not invalid to provide destination or source access masks for memory barriers used for release or acquire operations, respectively, they have no practical effect. Access after a release operation has undefined results, and so visibility for those accesses has no practical effect. Similarly, write access before an acquire operation will produce undefined results for future access, so availability of those writes has no practical use. In an earlier version of the specification, these were required to match on both sides - but this was subsequently relaxed. These masks should be set to 0.

If the transfer is via an image memory barrier, and an image layout transition is desired, then the values of oldLayout and newLayout in the release memory barrier must be equal to values of oldLayout and newLayout in the acquire memory barrier. Although the image layout transition is submitted twice, it will only be executed once. A layout transition specified in this way happens-after the release operation and happens-before the acquire operation.

If the values of srcQueueFamilyIndex and dstQueueFamilyIndex are equal, no ownership transfer is performed, and the barrier operates as if they were both set to VK_QUEUE_FAMILY_IGNORED.

Queue family ownership transfers may perform read and write accesses on all memory bound to the image subresource or buffer range, so applications must ensure that all memory writes have been made available before a queue family ownership transfer is executed. Available memory is automatically made visible to queue family release and acquire operations, and writes performed by those operations are automatically made available.

Once a queue family has acquired ownership of a buffer range or image subresource range of a VK_SHARING_MODE_EXCLUSIVE resource, its contents are undefined to other queue families unless ownership is transferred. The contents of any portion of another resource which aliases memory that is bound to the transferred buffer or image subresource range are undefined after a release or acquire operation.

Note

Because events cannot be used directly for inter-queue synchronization, and because vkCmdSetEvent does not have the queue family index or memory barrier parameters needed by a release operation, the release and acquire operations of a queue family ownership transfer can only be performed using vkCmdPipelineBarrier.

6.8. Wait Idle Operations

To wait on the host for the completion of outstanding queue operations for a given queue, call:

VkResult vkQueueWaitIdle(
    VkQueue                                     queue);

queue is the queue on which to wait.

vkQueueWaitIdle is equivalent to submitting a fence to a queue and waiting with an infinite timeout for that fence to signal.

Valid Usage (Implicit)

VUID-vkQueueWaitIdle-queue-parameter
queue must be a valid VkQueue handle

Host Synchronization

Host access to queue must be externally synchronized

Command Properties

Any

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST

To wait on the host for the completion of outstanding queue operations for all queues on a given logical device, call:

VkResult vkDeviceWaitIdle(
    VkDevice                                    device);

device is the logical device to idle.

vkDeviceWaitIdle is equivalent to calling vkQueueWaitIdle for all queues owned by device.

Valid Usage (Implicit)

VUID-vkDeviceWaitIdle-device-parameter
device must be a valid VkDevice handle

Host Synchronization

Host access to all VkQueue objects created from device must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST

6.9. Host Write Ordering Guarantees

When batches of command buffers are submitted to a queue via vkQueueSubmit, it defines a memory dependency with prior host operations, and execution of command buffers submitted to the queue.

The first synchronization scope is defined by the host execution model, but includes execution of vkQueueSubmit on the host and anything that happened-before it.

The second synchronization scope includes all commands submitted in the same queue submission, and all commands that occur later in submission order.

The first access scope includes all host writes to mappable device memory that are available to the host memory domain.

The second access scope includes all memory access performed by the device.

6.10. Synchronization and Multiple Physical Devices

If a logical device includes more than one physical device, then fences, semaphores, and events all still have a single instance of the signaled state.

A fence becomes signaled when all physical devices complete the necessary queue operations.

Semaphore wait and signal operations all include a device index that is the sole physical device that performs the operation. These indices are provided in the VkDeviceGroupSubmitInfo and VkDeviceGroupBindSparseInfo structures. Semaphores are not exclusively owned by any physical device. For example, a semaphore can be signaled by one physical device and then waited on by a different physical device.

An event can only be waited on by the same physical device that signaled it (or the host).

6.11. Calibrated timestamps

In order to be able to correlate the time a particular operation took place at on timelines of different time domains (e.g. a device operation vs a host operation), Vulkan allows querying calibrated timestamps from multiple time domains.

To query calibrated timestamps from a set of time domains, call:

VkResult vkGetCalibratedTimestampsEXT(
    VkDevice                                    device,
    uint32_t                                    timestampCount,
    const VkCalibratedTimestampInfoEXT*         pTimestampInfos,
    uint64_t*                                   pTimestamps,
    uint64_t*                                   pMaxDeviation);

device is the logical device used to perform the query.
timestampCount is the number of timestamps to query.
pTimestampInfos is a pointer to an array of timestampCount VkCalibratedTimestampInfoEXT structures, describing the time domains the calibrated timestamps should be captured from.
pTimestamps is a pointer to an array of timestampCount 64-bit unsigned integer values in which the requested calibrated timestamp values are returned.
pMaxDeviation is a pointer to a 64-bit unsigned integer value in which the strictly positive maximum deviation, in nanoseconds, of the calibrated timestamp values is returned.

Note

The maximum deviation may vary between calls to vkGetCalibratedTimestampsEXT even for the same set of time domains due to implementation and platform specific reasons. It is the application’s responsibility to assess whether the returned maximum deviation makes the timestamp values suitable for any particular purpose and can choose to re-issue the timestamp calibration call pursuing a lower devation value.

Calibrated timestamp values can be extrapolated to estimate future coinciding timestamp values, however, depending on the nature of the time domains and other properties of the platform extrapolating values over a sufficiently long period of time may no longer be accurate enough to fit any particular purpose so applications are expected to re-calibrate the timestamps on a regular basis.

Valid Usage (Implicit)

VUID-vkGetCalibratedTimestampsEXT-device-parameter
device must be a valid VkDevice handle
VUID-vkGetCalibratedTimestampsEXT-pTimestampInfos-parameter
pTimestampInfos must be a valid pointer to an array of timestampCount valid VkCalibratedTimestampInfoEXT structures
VUID-vkGetCalibratedTimestampsEXT-pTimestamps-parameter
pTimestamps must be a valid pointer to an array of timestampCount uint64_t values
VUID-vkGetCalibratedTimestampsEXT-pMaxDeviation-parameter
pMaxDeviation must be a valid pointer to a uint64_t value
VUID-vkGetCalibratedTimestampsEXT-timestampCount-arraylength
timestampCount must be greater than 0

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkCalibratedTimestampInfoEXT structure is defined as:

typedef struct VkCalibratedTimestampInfoEXT {
    VkStructureType    sType;
    const void*        pNext;
    VkTimeDomainEXT    timeDomain;
} VkCalibratedTimestampInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
timeDomain is a VkTimeDomainEXT value specifying the time domain from which the calibrated timestamp value should be returned.

Valid Usage

VUID-VkCalibratedTimestampInfoEXT-timeDomain-02354
timeDomain must be one of the VkTimeDomainEXT values returned by vkGetPhysicalDeviceCalibrateableTimeDomainsEXT

Valid Usage (Implicit)

VUID-VkCalibratedTimestampInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT
VUID-VkCalibratedTimestampInfoEXT-pNext-pNext
pNext must be NULL
VUID-VkCalibratedTimestampInfoEXT-timeDomain-parameter
timeDomain must be a valid VkTimeDomainEXT value

The set of supported time domains consists of:

typedef enum VkTimeDomainEXT {
    VK_TIME_DOMAIN_DEVICE_EXT = 0,
    VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1,
    VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2,
    VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3,
    VK_TIME_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF
} VkTimeDomainEXT;

VK_TIME_DOMAIN_DEVICE_EXT specifies the device time domain. Timestamp values in this time domain use the same units and are comparable with device timestamp values captured using vkCmdWriteTimestamp and are defined to be incrementing according to the timestampPeriod of the device.
VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT specifies the CLOCK_MONOTONIC time domain available on POSIX platforms. Timestamp values in this time domain are in units of nanoseconds and are comparable with platform timestamp values captured using the POSIX clock_gettime API as computed by this example:

struct timespec tv;
clock_gettime(CLOCK_MONOTONIC, &tv);
return tv.tv_nsec + tv.tv_sec*1000000000ull;

VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT specifies the CLOCK_MONOTONIC_RAW time domain available on POSIX platforms. Timestamp values in this time domain are in units of nanoseconds and are comparable with platform timestamp values captured using the POSIX clock_gettime API as computed by this example:

struct timespec tv;
clock_gettime(CLOCK_MONOTONIC_RAW, &tv);
return tv.tv_nsec + tv.tv_sec*1000000000ull;

VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT specifies the performance counter (QPC) time domain available on Windows. Timestamp values in this time domain are in the same units as those provided by the Windows QueryPerformanceCounter API and are comparable with platform timestamp values captured using that API as computed by this example:

LARGE_INTEGER counter;
QueryPerformanceCounter(&counter);
return counter.QuadPart;

7. Render Pass

A render pass represents a collection of attachments, subpasses, and dependencies between the subpasses, and describes how the attachments are used over the course of the subpasses. The use of a render pass in a command buffer is a render pass instance.

Render passes are represented by VkRenderPass handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)

An attachment description describes the properties of an attachment including its format, sample count, and how its contents are treated at the beginning and end of each render pass instance.

A subpass represents a phase of rendering that reads and writes a subset of the attachments in a render pass. Rendering commands are recorded into a particular subpass of a render pass instance.

A subpass description describes the subset of attachments that is involved in the execution of a subpass. Each subpass can read from some attachments as input attachments, write to some as color attachments or depth/stencil attachments, and perform multisample resolve operations to resolve attachments. A subpass description can also include a set of preserve attachments, which are attachments that are not read or written by the subpass but whose contents must be preserved throughout the subpass.

A subpass uses an attachment if the attachment is a color, depth/stencil, resolve, depth/stencil resolve, or input attachment for that subpass (as determined by the pColorAttachments, pDepthStencilAttachment, pResolveAttachments, VkSubpassDescriptionDepthStencilResolve::pDepthStencilResolveAttachment, and pInputAttachments members of VkSubpassDescription, respectively). A subpass does not use an attachment if that attachment is preserved by the subpass. The first use of an attachment is in the lowest numbered subpass that uses that attachment. Similarly, the last use of an attachment is in the highest numbered subpass that uses that attachment.

The subpasses in a render pass all render to the same dimensions, and fragments for pixel (x,y,layer) in one subpass can only read attachment contents written by previous subpasses at that same (x,y,layer) location.

Note

By describing a complete set of subpasses in advance, render passes provide the implementation an opportunity to optimize the storage and transfer of attachment data between subpasses.

In practice, this means that subpasses with a simple framebuffer-space dependency may be merged into a single tiled rendering pass, keeping the attachment data on-chip for the duration of a render pass instance. However, it is also quite common for a render pass to only contain a single subpass.

Subpass dependencies describe execution and memory dependencies between subpasses.

A subpass dependency chain is a sequence of subpass dependencies in a render pass, where the source subpass of each subpass dependency (after the first) equals the destination subpass of the previous dependency.

Execution of subpasses may overlap or execute out of order with regards to other subpasses, unless otherwise enforced by an execution dependency. Each subpass only respects submission order for commands recorded in the same subpass, and the vkCmdBeginRenderPass and vkCmdEndRenderPass commands that delimit the render pass - commands within other subpasses are not included. This affects most other implicit ordering guarantees.

A render pass describes the structure of subpasses and attachments independent of any specific image views for the attachments. The specific image views that will be used for the attachments, and their dimensions, are specified in VkFramebuffer objects. Framebuffers are created with respect to a specific render pass that the framebuffer is compatible with (see Render Pass Compatibility). Collectively, a render pass and a framebuffer define the complete render target state for one or more subpasses as well as the algorithmic dependencies between the subpasses.

The various pipeline stages of the drawing commands for a given subpass may execute concurrently and/or out of order, both within and across drawing commands, whilst still respecting pipeline order. However for a given (x,y,layer,sample) sample location, certain per-sample operations are performed in rasterization order.

7.1. Render Pass Creation

To create a render pass, call:

VkResult vkCreateRenderPass(
    VkDevice                                    device,
    const VkRenderPassCreateInfo*               pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkRenderPass*                               pRenderPass);

device is the logical device that creates the render pass.
pCreateInfo is a pointer to a VkRenderPassCreateInfo structure describing the parameters of the render pass.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pRenderPass is a pointer to a VkRenderPass handle in which the resulting render pass object is returned.

Valid Usage (Implicit)

VUID-vkCreateRenderPass-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateRenderPass-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkRenderPassCreateInfo structure
VUID-vkCreateRenderPass-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateRenderPass-pRenderPass-parameter
pRenderPass must be a valid pointer to a VkRenderPass handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkRenderPassCreateInfo structure is defined as:

typedef struct VkRenderPassCreateInfo {
    VkStructureType                   sType;
    const void*                       pNext;
    VkRenderPassCreateFlags           flags;
    uint32_t                          attachmentCount;
    const VkAttachmentDescription*    pAttachments;
    uint32_t                          subpassCount;
    const VkSubpassDescription*       pSubpasses;
    uint32_t                          dependencyCount;
    const VkSubpassDependency*        pDependencies;
} VkRenderPassCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
attachmentCount is the number of attachments used by this render pass.
pAttachments is a pointer to an array of attachmentCount VkAttachmentDescription structures describing the attachments used by the render pass.
subpassCount is the number of subpasses to create.
pSubpasses is a pointer to an array of subpassCount VkSubpassDescription structures describing each subpass.
dependencyCount is the number of memory dependencies between pairs of subpasses.
pDependencies is a pointer to an array of dependencyCount VkSubpassDependency structures describing dependencies between pairs of subpasses.

Note

Care should be taken to avoid a data race here; if any subpasses access attachments with overlapping memory locations, and one of those accesses is a write, a subpass dependency needs to be included between them.

Valid Usage

VUID-VkRenderPassCreateInfo-attachment-00834
If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or any element of pPreserveAttachments in any element of pSubpasses is not VK_ATTACHMENT_UNUSED, it must be less than attachmentCount
VUID-VkRenderPassCreateInfo-pAttachments-00836
For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL.
VUID-VkRenderPassCreateInfo-pAttachments-02511
For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL.
VUID-VkRenderPassCreateInfo-pAttachments-01566
For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL.
VUID-VkRenderPassCreateInfo-pAttachments-01567
For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL.
VUID-VkRenderPassCreateInfo-pNext-01926
If the pNext chain includes a VkRenderPassInputAttachmentAspectCreateInfo structure, the subpass member of each element of its pAspectReferences member must be less than subpassCount
VUID-VkRenderPassCreateInfo-pNext-01927
If the pNext chain includes a VkRenderPassInputAttachmentAspectCreateInfo structure, the inputAttachmentIndex member of each element of its pAspectReferences member must be less than the value of inputAttachmentCount in the member of pSubpasses identified by its subpass member
VUID-VkRenderPassCreateInfo-pNext-01963
If the pNext chain includes a VkRenderPassInputAttachmentAspectCreateInfo structure, for any element of the pInputAttachments member of any element of pSubpasses where the attachment member is not VK_ATTACHMENT_UNUSED, the aspectMask member of the corresponding element of VkRenderPassInputAttachmentAspectCreateInfo::pAspectReferences must only include aspects that are present in images of the format specified by the element of pAttachments at attachment
VUID-VkRenderPassCreateInfo-pNext-01928
If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, and its subpassCount member is not zero, that member must be equal to the value of subpassCount
VUID-VkRenderPassCreateInfo-pNext-01929
If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, if its dependencyCount member is not zero, it must be equal to dependencyCount
VUID-VkRenderPassCreateInfo-pNext-01930
If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, for each non-zero element of pViewOffsets, the srcSubpass and dstSubpass members of pDependencies at the same index must not be equal
VUID-VkRenderPassCreateInfo-pNext-02512
If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, for any element of pDependencies with a dependencyFlags member that does not include VK_DEPENDENCY_VIEW_LOCAL_BIT, the corresponding element of the pViewOffsets member of that VkRenderPassMultiviewCreateInfo instance must be 0
VUID-VkRenderPassCreateInfo-pNext-02513
If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, elements of its pViewMasks member must either all be 0, or all not be 0
VUID-VkRenderPassCreateInfo-pNext-02514
If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, and each element of its pViewMasks member is 0, the dependencyFlags member of each element of pDependencies must not include VK_DEPENDENCY_VIEW_LOCAL_BIT
VUID-VkRenderPassCreateInfo-pNext-02515
If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, and each element of its pViewMasks member is 0, correlatedViewMaskCount must be 0
VUID-VkRenderPassCreateInfo-pNext-02516
If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, each element of its pViewMask member must not have a bit set at an index greater than or equal to VkPhysicalDeviceLimits::maxFramebufferLayers
VUID-VkRenderPassCreateInfo-pDependencies-00837
For any element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass
VUID-VkRenderPassCreateInfo-pDependencies-00838
For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the destination subpass
VUID-VkRenderPassCreateInfo-srcSubpass-02517
The srcSubpass member of each element of pDependencies must be less than subpassCount
VUID-VkRenderPassCreateInfo-dstSubpass-02518
The dstSubpass member of each element of pDependencies must be less than subpassCount

Valid Usage (Implicit)

VUID-VkRenderPassCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
VUID-VkRenderPassCreateInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkRenderPassFragmentDensityMapCreateInfoEXT, VkRenderPassInputAttachmentAspectCreateInfo, or VkRenderPassMultiviewCreateInfo
VUID-VkRenderPassCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkRenderPassCreateInfo-flags-zerobitmask
flags must be 0
VUID-VkRenderPassCreateInfo-pAttachments-parameter
If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription structures
VUID-VkRenderPassCreateInfo-pSubpasses-parameter
pSubpasses must be a valid pointer to an array of subpassCount valid VkSubpassDescription structures
VUID-VkRenderPassCreateInfo-pDependencies-parameter
If dependencyCount is not 0, pDependencies must be a valid pointer to an array of dependencyCount valid VkSubpassDependency structures
VUID-VkRenderPassCreateInfo-subpassCount-arraylength
subpassCount must be greater than 0

typedef VkFlags VkRenderPassCreateFlags;

VkRenderPassCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

If the VkRenderPassCreateInfo::pNext chain includes a VkRenderPassMultiviewCreateInfo structure, then that structure includes an array of view masks, view offsets, and correlation masks for the render pass.

The VkRenderPassMultiviewCreateInfo structure is defined as:

typedef struct VkRenderPassMultiviewCreateInfo {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           subpassCount;
    const uint32_t*    pViewMasks;
    uint32_t           dependencyCount;
    const int32_t*     pViewOffsets;
    uint32_t           correlationMaskCount;
    const uint32_t*    pCorrelationMasks;
} VkRenderPassMultiviewCreateInfo;

or the equivalent

typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
subpassCount is zero or the number of subpasses in the render pass.
pViewMasks is a pointer to an array of subpassCount view masks, where each mask is a bitfield of view indices describing which views rendering is broadcast to in each subpass, when multiview is enabled. If subpassCount is zero, each view mask is treated as zero.
dependencyCount is zero or the number of dependencies in the render pass.
pViewOffsets is a pointer to an array of dependencyCount view offsets, one for each dependency. If dependencyCount is zero, each dependency’s view offset is treated as zero. Each view offset controls which views in the source subpass the views in the destination subpass depend on.
correlationMaskCount is zero or the number of correlation masks.
pCorrelationMasks is a pointer to an array of correlationMaskCount view masks indicating sets of views that may be more efficient to render concurrently.

When a subpass uses a non-zero view mask, multiview functionality is considered to be enabled. Multiview is all-or-nothing for a render pass - that is, either all subpasses must have a non-zero view mask (though some subpasses may have only one view) or all must be zero. Multiview causes all drawing and clear commands in the subpass to behave as if they were broadcast to each view, where a view is represented by one layer of the framebuffer attachments. All draws and clears are broadcast to each view index whose bit is set in the view mask. The view index is provided in the ViewIndex shader input variable, and color, depth/stencil, and input attachments all read/write the layer of the framebuffer corresponding to the view index.

If the view mask is zero for all subpasses, multiview is considered to be disabled and all drawing commands execute normally, without this additional broadcasting.

Some implementations may not support multiview in conjunction with geometry shaders or tessellation shaders.

When multiview is enabled, the VK_DEPENDENCY_VIEW_LOCAL_BIT bit in a dependency can be used to express a view-local dependency, meaning that each view in the destination subpass depends on a single view in the source subpass. Unlike pipeline barriers, a subpass dependency can potentially have a different view mask in the source subpass and the destination subpass. If the dependency is view-local, then each view (dstView) in the destination subpass depends on the view dstView + pViewOffsets[dependency] in the source subpass. If there is not such a view in the source subpass, then this dependency does not affect that view in the destination subpass. If the dependency is not view-local, then all views in the destination subpass depend on all views in the source subpass, and the view offset is ignored. A non-zero view offset is not allowed in a self-dependency.

The elements of pCorrelationMasks are a set of masks of views indicating that views in the same mask may exhibit spatial coherency between the views, making it more efficient to render them concurrently. Correlation masks must not have a functional effect on the results of the multiview rendering.

When multiview is enabled, at the beginning of each subpass all non-render pass state is undefined. In particular, each time vkCmdBeginRenderPass or vkCmdNextSubpass is called the graphics pipeline must be bound, any relevant descriptor sets or vertex/index buffers must be bound, and any relevant dynamic state or push constants must be set before they are used.

A multiview subpass can declare that its shaders will write per-view attributes for all views in a single invocation, by setting the VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX bit in the subpass description. The only supported per-view attributes are position and viewport mask, and per-view position and viewport masks are written to output array variables decorated with PositionPerViewNV and ViewportMaskPerViewNV, respectively. If VK_NV_viewport_array2 is not supported and enabled, ViewportMaskPerViewNV must not be used. Values written to elements of PositionPerViewNV and ViewportMaskPerViewNV must not depend on the ViewIndex. The shader must also write to an output variable decorated with Position, and the value written to Position must equal the value written to PositionPerViewNV[ViewIndex]. Similarly, if ViewportMaskPerViewNV is written to then the shader must also write to an output variable decorated with ViewportMaskNV, and the value written to ViewportMaskNV must equal the value written to ViewportMaskPerViewNV[ViewIndex]. Implementations will either use values taken from Position and ViewportMaskNV and invoke the shader once for each view, or will use values taken from PositionPerViewNV and ViewportMaskPerViewNV and invoke the shader fewer times. The values written to Position and ViewportMaskNV must not depend on the values written to PositionPerViewNV and ViewportMaskPerViewNV, or vice versa (to allow compilers to eliminate the unused outputs). All attributes that do not have *PerViewNV counterparts must not depend on ViewIndex.

Per-view attributes are all-or-nothing for a subpass. That is, all pipelines compiled against a subpass that includes the VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX bit must write per-view attributes to the *PerViewNV[] shader outputs, in addition to the non-per-view (e.g. Position) outputs. Pipelines compiled against a subpass that does not include this bit must not include the *PerViewNV[] outputs in their interfaces.

Valid Usage

VUID-VkRenderPassMultiviewCreateInfo-pCorrelationMasks-00841
Each view index must not be set in more than one element of pCorrelationMasks

Valid Usage (Implicit)

VUID-VkRenderPassMultiviewCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO
VUID-VkRenderPassMultiviewCreateInfo-pViewMasks-parameter
If subpassCount is not 0, pViewMasks must be a valid pointer to an array of subpassCount uint32_t values
VUID-VkRenderPassMultiviewCreateInfo-pViewOffsets-parameter
If dependencyCount is not 0, pViewOffsets must be a valid pointer to an array of dependencyCount int32_t values
VUID-VkRenderPassMultiviewCreateInfo-pCorrelationMasks-parameter
If correlationMaskCount is not 0, pCorrelationMasks must be a valid pointer to an array of correlationMaskCount uint32_t values

If the VkRenderPassCreateInfo::pNext chain includes a VkRenderPassFragmentDensityMapCreateInfoEXT structure, then that structure includes a fragment density map attachment for the render pass.

The VkRenderPassFragmentDensityMapCreateInfoEXT structure is defined as:

typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT {
    VkStructureType          sType;
    const void*              pNext;
    VkAttachmentReference    fragmentDensityMapAttachment;
} VkRenderPassFragmentDensityMapCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
fragmentDensityMapAttachment is the fragment density map to use for the render pass.

The fragment density map attachment is read at an implementation-dependent time either by the host during vkCmdBeginRenderPass if the attachment’s image view was not created with flags containing VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT, or by the device when drawing commands in the renderpass execute VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT.

If this structure is not present, it is as if fragmentDensityMapAttachment was given as VK_ATTACHMENT_UNUSED.

Valid Usage

VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02547
If fragmentDensityMapAttachment is not VK_ATTACHMENT_UNUSED, fragmentDensityMapAttachment must be less than VkRenderPassCreateInfo::attachmentCount
VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02548
If fragmentDensityMapAttachment is not VK_ATTACHMENT_UNUSED, fragmentDensityMapAttachment must not be an element of VkSubpassDescription::pInputAttachments, VkSubpassDescription::pColorAttachments, VkSubpassDescription::pResolveAttachments, VkSubpassDescription::pDepthStencilAttachment, or VkSubpassDescription::pPreserveAttachments for any subpass
VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02549
If fragmentDensityMapAttachment is not VK_ATTACHMENT_UNUSED, layout must be equal to VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT, or VK_IMAGE_LAYOUT_GENERAL
VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02550
If fragmentDensityMapAttachment is not VK_ATTACHMENT_UNUSED, fragmentDensityMapAttachment must reference an attachment with a loadOp equal to VK_ATTACHMENT_LOAD_OP_LOAD or VK_ATTACHMENT_LOAD_OP_DONT_CARE.
VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02551
If fragmentDensityMapAttachment is not VK_ATTACHMENT_UNUSED, fragmentDensityMapAttachment must reference an attachment with a storeOp equal to VK_ATTACHMENT_STORE_OP_DONT_CARE.

Valid Usage (Implicit)

VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT
VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-parameter
fragmentDensityMapAttachment must be a valid VkAttachmentReference structure

The VkAttachmentDescription structure is defined as:

typedef struct VkAttachmentDescription {
    VkAttachmentDescriptionFlags    flags;
    VkFormat                        format;
    VkSampleCountFlagBits           samples;
    VkAttachmentLoadOp              loadOp;
    VkAttachmentStoreOp             storeOp;
    VkAttachmentLoadOp              stencilLoadOp;
    VkAttachmentStoreOp             stencilStoreOp;
    VkImageLayout                   initialLayout;
    VkImageLayout                   finalLayout;
} VkAttachmentDescription;

flags is a bitmask of VkAttachmentDescriptionFlagBits specifying additional properties of the attachment.
format is a VkFormat value specifying the format of the image view that will be used for the attachment.
samples is the number of samples of the image as defined in VkSampleCountFlagBits.
loadOp is a VkAttachmentLoadOp value specifying how the contents of color and depth components of the attachment are treated at the beginning of the subpass where it is first used.
storeOp is a VkAttachmentStoreOp value specifying how the contents of color and depth components of the attachment are treated at the end of the subpass where it is last used.
stencilLoadOp is a VkAttachmentLoadOp value specifying how the contents of stencil components of the attachment are treated at the beginning of the subpass where it is first used.
stencilStoreOp is a VkAttachmentStoreOp value specifying how the contents of stencil components of the attachment are treated at the end of the last subpass where it is used.
initialLayout is the layout the attachment image subresource will be in when a render pass instance begins.
finalLayout is the layout the attachment image subresource will be transitioned to when a render pass instance ends.

If the attachment uses a color format, then loadOp and storeOp are used, and stencilLoadOp and stencilStoreOp are ignored. If the format has depth and/or stencil components, loadOp and storeOp apply only to the depth data, while stencilLoadOp and stencilStoreOp define how the stencil data is handled. loadOp and stencilLoadOp define the load operations that execute as part of the first subpass that uses the attachment. storeOp and stencilStoreOp define the store operations that execute as part of the last subpass that uses the attachment.

The load operation for each sample in an attachment happens-before any recorded command which accesses the sample in the first subpass where the attachment is used. Load operations for attachments with a depth/stencil format execute in the VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT pipeline stage. Load operations for attachments with a color format execute in the VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT pipeline stage.

The store operation for each sample in an attachment happens-after any recorded command which accesses the sample in the last subpass where the attachment is used. Store operations for attachments with a depth/stencil format execute in the VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT pipeline stage. Store operations for attachments with a color format execute in the VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT pipeline stage.

If an attachment is not used by any subpass, then loadOp, storeOp, stencilStoreOp, and stencilLoadOp are ignored, and the attachment’s memory contents will not be modified by execution of a render pass instance.

The load and store operations apply on the first and last use of each view in the render pass, respectively. If a view index of an attachment is not included in the view mask in any subpass that uses it, then the load and store operations are ignored, and the attachment’s memory contents will not be modified by execution of a render pass instance.

During a render pass instance, input/color attachments with color formats that have a component size of 8, 16, or 32 bits must be represented in the attachment’s format throughout the instance. Attachments with other floating- or fixed-point color formats, or with depth components may be represented in a format with a precision higher than the attachment format, but must be represented with the same range. When such a component is loaded via the loadOp, it will be converted into an implementation-dependent format used by the render pass. Such components must be converted from the render pass format, to the format of the attachment, before they are resolved or stored at the end of a render pass instance via storeOp. Conversions occur as described in Numeric Representation and Computation and Fixed-Point Data Conversions.

If flags includes VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT, 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 VK_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 ranges.

Note

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. These dependencies must not include the VK_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. The precise set of valid scenarios is described in more detail below.

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 VK_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.

Note

Once an attachment needs the VK_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 VK_ATTACHMENT_LOAD_OP_CLEAR.

Valid Usage

VUID-VkAttachmentDescription-finalLayout-00843
finalLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED
VUID-VkAttachmentDescription-format-03280
If format is a color format, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
VUID-VkAttachmentDescription-format-03281
If format is a depth/stencil format, initialLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
VUID-VkAttachmentDescription-format-03282
If format is a color format, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
VUID-VkAttachmentDescription-format-03283
If format is a depth/stencil format, finalLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
VUID-VkAttachmentDescription-separateDepthStencilLayouts-03284
If the separateDepthStencilLayouts feature is not enabled, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL
VUID-VkAttachmentDescription-separateDepthStencilLayouts-03285
If the separateDepthStencilLayouts feature is not enabled, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL
VUID-VkAttachmentDescription-format-03286
If format is a color format, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL
VUID-VkAttachmentDescription-format-03287
If format is a color format, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL
VUID-VkAttachmentDescription-format-03288
If format is a depth/stencil format which includes both depth and stencil aspects, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL
VUID-VkAttachmentDescription-format-03289
If format is a depth/stencil format which includes both depth and stencil aspects, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL
VUID-VkAttachmentDescription-format-03290
If format is a depth/stencil format which includes only the depth aspect, initialLayout must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL
VUID-VkAttachmentDescription-format-03291
If format is a depth/stencil format which includes only the depth aspect, finalLayout must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL
VUID-VkAttachmentDescription-format-03292
If format is a depth/stencil format which includes only the stencil aspect, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL
VUID-VkAttachmentDescription-format-03293
If format is a depth/stencil format which includes only the stencil aspect, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL

Valid Usage (Implicit)

VUID-VkAttachmentDescription-flags-parameter
flags must be a valid combination of VkAttachmentDescriptionFlagBits values
VUID-VkAttachmentDescription-format-parameter
format must be a valid VkFormat value
VUID-VkAttachmentDescription-samples-parameter
samples must be a valid VkSampleCountFlagBits value
VUID-VkAttachmentDescription-loadOp-parameter
loadOp must be a valid VkAttachmentLoadOp value
VUID-VkAttachmentDescription-storeOp-parameter
storeOp must be a valid VkAttachmentStoreOp value
VUID-VkAttachmentDescription-stencilLoadOp-parameter
stencilLoadOp must be a valid VkAttachmentLoadOp value
VUID-VkAttachmentDescription-stencilStoreOp-parameter
stencilStoreOp must be a valid VkAttachmentStoreOp value
VUID-VkAttachmentDescription-initialLayout-parameter
initialLayout must be a valid VkImageLayout value
VUID-VkAttachmentDescription-finalLayout-parameter
finalLayout must be a valid VkImageLayout value

Bits which can be set in VkAttachmentDescription::flags describing additional properties of the attachment are:

typedef enum VkAttachmentDescriptionFlagBits {
    VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
    VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkAttachmentDescriptionFlagBits;

VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT specifies that the attachment aliases the same device memory as other attachments.

typedef VkFlags VkAttachmentDescriptionFlags;

VkAttachmentDescriptionFlags is a bitmask type for setting a mask of zero or more VkAttachmentDescriptionFlagBits.

Possible values of VkAttachmentDescription::loadOp and stencilLoadOp, specifying how the contents of the attachment are treated, are:

typedef enum VkAttachmentLoadOp {
    VK_ATTACHMENT_LOAD_OP_LOAD = 0,
    VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
    VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
    VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
} VkAttachmentLoadOp;

VK_ATTACHMENT_LOAD_OP_LOAD specifies that the previous contents of the image within the render area will be preserved. For attachments with a depth/stencil format, this uses the access type VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT. For attachments with a color format, this uses the access type VK_ACCESS_COLOR_ATTACHMENT_READ_BIT.
VK_ATTACHMENT_LOAD_OP_CLEAR specifies that the contents within the render area will be cleared to a uniform value, which is specified when a render pass instance is begun. For attachments with a depth/stencil format, this uses the access type VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT. For attachments with a color format, this uses the access type VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT.
VK_ATTACHMENT_LOAD_OP_DONT_CARE specifies that the previous contents within the area need not be preserved; the contents of the attachment will be undefined inside the render area. For attachments with a depth/stencil format, this uses the access type VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT. For attachments with a color format, this uses the access type VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT.

Possible values of VkAttachmentDescription::storeOp and stencilStoreOp, specifying how the contents of the attachment are treated, are:

typedef enum VkAttachmentStoreOp {
    VK_ATTACHMENT_STORE_OP_STORE = 0,
    VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
    VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
} VkAttachmentStoreOp;

VK_ATTACHMENT_STORE_OP_STORE specifies the contents generated during the render pass and within the render area are written to memory. For attachments with a depth/stencil format, this uses the access type VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT. For attachments with a color format, this uses the access type VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT.
VK_ATTACHMENT_STORE_OP_DONT_CARE specifies 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. For attachments with a depth/stencil format, this uses the access type VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT. For attachments with a color format, this uses the access type VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT.

Note

VK_ATTACHMENT_STORE_OP_DONT_CARE can cause contents generated during previous render passes to be discarded before reaching memory, even if no write to the attachment occurs during the current render pass.

To specify which aspects of an input attachment can be read, add a VkRenderPassInputAttachmentAspectCreateInfo structure to the pNext chain of the VkRenderPassCreateInfo structure:

The VkRenderPassInputAttachmentAspectCreateInfo structure is defined as:

typedef struct VkRenderPassInputAttachmentAspectCreateInfo {
    VkStructureType                            sType;
    const void*                                pNext;
    uint32_t                                   aspectReferenceCount;
    const VkInputAttachmentAspectReference*    pAspectReferences;
} VkRenderPassInputAttachmentAspectCreateInfo;

or the equivalent

typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
aspectReferenceCount is the number of elements in the pAspectReferences array.
pAspectReferences is a pointer to an array of aspectReferenceCount VkInputAttachmentAspectReference structures containing a mask describing which aspect(s) can be accessed for a given input attachment within a given subpass.

An application can access any aspect of an input attachment that does not have a specified aspect mask in the pAspectReferences array. Otherwise, an application must not access aspect(s) of an input attachment other than those in its specified aspect mask.

Valid Usage (Implicit)

VUID-VkRenderPassInputAttachmentAspectCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO
VUID-VkRenderPassInputAttachmentAspectCreateInfo-pAspectReferences-parameter
pAspectReferences must be a valid pointer to an array of aspectReferenceCount valid VkInputAttachmentAspectReference structures
VUID-VkRenderPassInputAttachmentAspectCreateInfo-aspectReferenceCount-arraylength
aspectReferenceCount must be greater than 0

The VkInputAttachmentAspectReference structure specifies an aspect mask for a specific input attachment of a specific subpass in the render pass.

subpass and inputAttachmentIndex index into the render pass as:

pCreateInfo->pSubpasses[subpass].pInputAttachments[inputAttachmentIndex]

typedef struct VkInputAttachmentAspectReference {
    uint32_t              subpass;
    uint32_t              inputAttachmentIndex;
    VkImageAspectFlags    aspectMask;
} VkInputAttachmentAspectReference;

or the equivalent

typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR;

subpass is an index into the pSubpasses array of the parent VkRenderPassCreateInfo structure.
inputAttachmentIndex is an index into the pInputAttachments of the specified subpass.
aspectMask is a mask of which aspect(s) can be accessed within the specified subpass.

Valid Usage

VUID-VkInputAttachmentAspectReference-aspectMask-01964
aspectMask must not include VK_IMAGE_ASPECT_METADATA_BIT
VUID-VkInputAttachmentAspectReference-aspectMask-02250
aspectMask must not include VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT for any index i.

Valid Usage (Implicit)

VUID-VkInputAttachmentAspectReference-aspectMask-parameter
aspectMask must be a valid combination of VkImageAspectFlagBits values
VUID-VkInputAttachmentAspectReference-aspectMask-requiredbitmask
aspectMask must not be 0

The VkSubpassDescription structure is defined as:

typedef struct VkSubpassDescription {
    VkSubpassDescriptionFlags       flags;
    VkPipelineBindPoint             pipelineBindPoint;
    uint32_t                        inputAttachmentCount;
    const VkAttachmentReference*    pInputAttachments;
    uint32_t                        colorAttachmentCount;
    const VkAttachmentReference*    pColorAttachments;
    const VkAttachmentReference*    pResolveAttachments;
    const VkAttachmentReference*    pDepthStencilAttachment;
    uint32_t                        preserveAttachmentCount;
    const uint32_t*                 pPreserveAttachments;
} VkSubpassDescription;

flags is a bitmask of VkSubpassDescriptionFlagBits specifying usage of the subpass.
pipelineBindPoint is a VkPipelineBindPoint value specifying the pipeline type supported for this subpass.
inputAttachmentCount is the number of input attachments.
pInputAttachments is a pointer to an array of VkAttachmentReference structures defining the input attachments for this subpass and their layouts.
colorAttachmentCount is the number of color attachments.
pColorAttachments is a pointer to an array of VkAttachmentReference structures defining the color attachments for this subpass and their layouts.
pResolveAttachments is an optional array of colorAttachmentCount VkAttachmentReference structures defining the resolve attachments for this subpass and their layouts.
pDepthStencilAttachment is a pointer to a VkAttachmentReference structure specifying the depth/stencil attachment for this subpass and its layout.
preserveAttachmentCount is the number of preserved attachments.
pPreserveAttachments is a pointer to an array of preserveAttachmentCount render pass attachment indices identifying attachments that are not used by this subpass, but whose contents must be preserved throughout the subpass.

Each element of the pInputAttachments array corresponds to an input attachment index in a fragment shader, i.e. if a shader declares an image variable decorated with a InputAttachmentIndex value of X, then it uses the attachment provided in pInputAttachments[X]. Input attachments must also be bound to the pipeline in a descriptor set. If the attachment member of any element of pInputAttachments is VK_ATTACHMENT_UNUSED, the application must not read from the corresponding input attachment index. Fragment shaders can use subpass input variables to access the contents of an input attachment at the fragment’s (x, y, layer) framebuffer coordinates.

Each element of the pColorAttachments array corresponds to an output location in the shader, i.e. if the shader declares an output variable decorated with a Location value of X, then it uses the attachment provided in pColorAttachments[X]. If the attachment member of any element of pColorAttachments is VK_ATTACHMENT_UNUSED, writes to the corresponding location by a fragment are discarded.

If pResolveAttachments is not NULL, each of its elements corresponds to a color attachment (the element in pColorAttachments at the same index), and a multisample resolve operation is defined for each attachment. At the end of each subpass, multisample resolve operations read the subpass’s color attachments, and resolve the samples for each pixel within the render area to the same pixel location in the corresponding resolve attachments, unless the resolve attachment index is VK_ATTACHMENT_UNUSED.

Similarly, if VkSubpassDescriptionDepthStencilResolve::pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED, it corresponds to the depth/stencil attachment in pDepthStencilAttachment, and multisample resolve operations for depth and stencil are defined by VkSubpassDescriptionDepthStencilResolve::depthResolveMode and VkSubpassDescriptionDepthStencilResolve::stencilResolveMode, respectively. At the end of each subpass, multisample resolve operations read the subpass’s depth/stencil attachment, and resolve the samples for each pixel to the same pixel location in the corresponding resolve attachment. If VkSubpassDescriptionDepthStencilResolve::depthResolveMode is VK_RESOLVE_MODE_NONE, then the depth component of the resolve attachment is not written to and its contents are preserved. Similarly, if VkSubpassDescriptionDepthStencilResolve::stencilResolveMode is VK_RESOLVE_MODE_NONE, then the stencil component of the resolve attachment is not written to and its contents are preserved. VkSubpassDescriptionDepthStencilResolve::depthResolveMode is ignored if the VkFormat of the pDepthStencilResolveAttachment does not have a depth component. Similarly, VkSubpassDescriptionDepthStencilResolve::stencilResolveMode is ignored if the VkFormat of the pDepthStencilResolveAttachment does not have a stencil component.

If the image subresource range referenced by the depth/stencil attachment is created with VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT, then the multisample resolve operation uses the sample locations state specified in the sampleLocationsInfo member of the element of the VkRenderPassSampleLocationsBeginInfoEXT::pPostSubpassSampleLocations for the subpass.

If pDepthStencilAttachment is NULL, or if its attachment index is VK_ATTACHMENT_UNUSED, it indicates that no depth/stencil attachment will be used in the subpass.

The contents of an attachment within the render area become undefined at the start of a subpass S if all of the following conditions are true:

The attachment is used as a color, depth/stencil, or resolve attachment in any subpass in the render pass.
There is a subpass S₁ that uses or preserves the attachment, and a subpass dependency from S₁ to S.
The attachment is not used or preserved in subpass S.

Once the contents of an attachment become undefined in subpass S, they remain undefined for subpasses in subpass dependency chains starting with subpass S until they are written again. However, they remain valid for subpasses in other subpass dependency chains starting with subpass S₁ if those subpasses use or preserve the attachment.

Valid Usage

VUID-VkSubpassDescription-pipelineBindPoint-00844
pipelineBindPoint must be VK_PIPELINE_BIND_POINT_GRAPHICS
VUID-VkSubpassDescription-colorAttachmentCount-00845
colorAttachmentCount must be less than or equal to VkPhysicalDeviceLimits::maxColorAttachments
VUID-VkSubpassDescription-loadOp-00846
If the first use of an attachment in this render pass is as an input attachment, and the attachment is not also used as a color or depth/stencil attachment in the same subpass, then loadOp must not be VK_ATTACHMENT_LOAD_OP_CLEAR
VUID-VkSubpassDescription-pResolveAttachments-00847
If pResolveAttachments is not NULL, for each resolve attachment that is not VK_ATTACHMENT_UNUSED, the corresponding color attachment must not be VK_ATTACHMENT_UNUSED
VUID-VkSubpassDescription-pResolveAttachments-00848
If pResolveAttachments is not NULL, for each resolve attachment that is not VK_ATTACHMENT_UNUSED, the corresponding color attachment must not have a sample count of VK_SAMPLE_COUNT_1_BIT
VUID-VkSubpassDescription-pResolveAttachments-00849
If pResolveAttachments is not NULL, each resolve attachment that is not VK_ATTACHMENT_UNUSED must have a sample count of VK_SAMPLE_COUNT_1_BIT
VUID-VkSubpassDescription-pResolveAttachments-00850
If pResolveAttachments is not NULL, each resolve attachment that is not VK_ATTACHMENT_UNUSED must have the same VkFormat as its corresponding color attachment
VUID-VkSubpassDescription-pColorAttachments-01417
All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have the same sample count
VUID-VkSubpassDescription-pInputAttachments-02647
All attachments in pInputAttachments that are not VK_ATTACHMENT_UNUSED must have formats whose features contain at least one of VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT or VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT.
VUID-VkSubpassDescription-pColorAttachments-02648
All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have formats whose features contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
VUID-VkSubpassDescription-pResolveAttachments-02649
All attachments in pResolveAttachments that are not VK_ATTACHMENT_UNUSED must have formats whose features contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
VUID-VkSubpassDescription-pDepthStencilAttachment-02650
If pDepthStencilAttachment is not NULL and the attachment is not VK_ATTACHMENT_UNUSED then it must have a format whose features contain VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
VUID-VkSubpassDescription-pColorAttachments-01506
If the VK_AMD_mixed_attachment_samples extension is enabled, and all attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have a sample count that is smaller than or equal to the sample count of pDepthStencilAttachment if it is not VK_ATTACHMENT_UNUSED
VUID-VkSubpassDescription-pDepthStencilAttachment-01418
If neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, and if pDepthStencilAttachment is not VK_ATTACHMENT_UNUSED and any attachments in pColorAttachments are not VK_ATTACHMENT_UNUSED, they must have the same sample count
VUID-VkSubpassDescription-attachment-00853
The attachment member of each element of pPreserveAttachments must not be VK_ATTACHMENT_UNUSED
VUID-VkSubpassDescription-pPreserveAttachments-00854
Each element of pPreserveAttachments must not also be an element of any other member of the subpass description
VUID-VkSubpassDescription-layout-02519
If any attachment is used by more than one VkAttachmentReference member, then each use must use the same layout
VUID-VkSubpassDescription-flags-00856
If flags includes VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX, it must also include VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX.

Valid Usage (Implicit)

VUID-VkSubpassDescription-flags-parameter
flags must be a valid combination of VkSubpassDescriptionFlagBits values
VUID-VkSubpassDescription-pipelineBindPoint-parameter
pipelineBindPoint must be a valid VkPipelineBindPoint value
VUID-VkSubpassDescription-pInputAttachments-parameter
If inputAttachmentCount is not 0, pInputAttachments must be a valid pointer to an array of inputAttachmentCount valid VkAttachmentReference structures
VUID-VkSubpassDescription-pColorAttachments-parameter
If colorAttachmentCount is not 0, pColorAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference structures
VUID-VkSubpassDescription-pResolveAttachments-parameter
If colorAttachmentCount is not 0, and pResolveAttachments is not NULL, pResolveAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference structures
VUID-VkSubpassDescription-pDepthStencilAttachment-parameter
If pDepthStencilAttachment is not NULL, pDepthStencilAttachment must be a valid pointer to a valid VkAttachmentReference structure
VUID-VkSubpassDescription-pPreserveAttachments-parameter
If preserveAttachmentCount is not 0, pPreserveAttachments must be a valid pointer to an array of preserveAttachmentCount uint32_t values

Bits which can be set in VkSubpassDescription::flags, specifying usage of the subpass, are:

typedef enum VkSubpassDescriptionFlagBits {
    VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001,
    VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,
    VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkSubpassDescriptionFlagBits;

VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX specifies that shaders compiled for this subpass write the attributes for all views in a single invocation of each vertex processing stage. All pipelines compiled against a subpass that includes this bit must write per-view attributes to the *PerViewNV[] shader outputs, in addition to the non-per-view (e.g. Position) outputs.
VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX specifies that shaders compiled for this subpass use per-view positions which only differ in value in the x component. Per-view viewport mask can also be used.

typedef VkFlags VkSubpassDescriptionFlags;

VkSubpassDescriptionFlags is a bitmask type for setting a mask of zero or more VkSubpassDescriptionFlagBits.

The VkAttachmentReference structure is defined as:

typedef struct VkAttachmentReference {
    uint32_t         attachment;
    VkImageLayout    layout;
} VkAttachmentReference;

attachment is either an integer value identifying an attachment at the corresponding index in VkRenderPassCreateInfo::pAttachments, or VK_ATTACHMENT_UNUSED to signify that this attachment is not used.
layout is a VkImageLayout value specifying the layout the attachment uses during the subpass.

Valid Usage

VUID-VkAttachmentReference-layout-00857
If attachment is not VK_ATTACHMENT_UNUSED, layout must not be VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PREINITIALIZED, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR

Valid Usage (Implicit)

VUID-VkAttachmentReference-layout-parameter
layout must be a valid VkImageLayout value

The VkSubpassDependency structure is defined as:

typedef struct VkSubpassDependency {
    uint32_t                srcSubpass;
    uint32_t                dstSubpass;
    VkPipelineStageFlags    srcStageMask;
    VkPipelineStageFlags    dstStageMask;
    VkAccessFlags           srcAccessMask;
    VkAccessFlags           dstAccessMask;
    VkDependencyFlags       dependencyFlags;
} VkSubpassDependency;

srcSubpass is the subpass index of the first subpass in the dependency, or VK_SUBPASS_EXTERNAL.
dstSubpass is the subpass index of the second subpass in the dependency, or VK_SUBPASS_EXTERNAL.
srcStageMask is a bitmask of VkPipelineStageFlagBits specifying the source stage mask.
dstStageMask is a bitmask of VkPipelineStageFlagBits specifying the destination stage mask
srcAccessMask is a bitmask of VkAccessFlagBits specifying a source access mask.
dstAccessMask is a bitmask of VkAccessFlagBits specifying a destination access mask.
dependencyFlags is a bitmask of VkDependencyFlagBits.

If srcSubpass is equal to dstSubpass then the VkSubpassDependency describes a subpass self-dependency, and only constrains the pipeline barriers allowed within a subpass instance. Otherwise, when a render pass instance which includes a subpass dependency is submitted to a queue, it defines a memory dependency between the subpasses identified by srcSubpass and dstSubpass.

If srcSubpass is equal to VK_SUBPASS_EXTERNAL, the first synchronization scope includes commands that occur earlier in submission order than the vkCmdBeginRenderPass used to begin the render pass instance. Otherwise, the first set of commands includes all commands submitted as part of the subpass instance identified by srcSubpass and any load, store or multisample resolve operations on attachments used in srcSubpass. In either case, the first synchronization scope is limited to operations on the pipeline stages determined by the source stage mask specified by srcStageMask.

If dstSubpass is equal to VK_SUBPASS_EXTERNAL, the second synchronization scope includes commands that occur later in submission order than the vkCmdEndRenderPass used to end the render pass instance. Otherwise, the second set of commands includes all commands submitted as part of the subpass instance identified by dstSubpass and any load, store or multisample resolve operations on attachments used in dstSubpass. In either case, the second synchronization scope is limited to operations on the pipeline stages determined by the destination stage mask specified by dstStageMask.

The first access scope is limited to access in the pipeline stages determined by the source stage mask specified by srcStageMask. It is also limited to access types in the source access mask specified by srcAccessMask.

The second access scope is limited to access in the pipeline stages determined by the destination stage mask specified by dstStageMask. It is also limited to access types in the destination access mask specified by dstAccessMask.

The availability and visibility operations defined by a subpass dependency affect the execution of image layout transitions within the render pass.

Note

For non-attachment resources, the memory dependency expressed by subpass dependency is nearly identical to that of a VkMemoryBarrier (with matching srcAccessMask and dstAccessMask parameters) submitted as a part of a vkCmdPipelineBarrier (with matching srcStageMask and dstStageMask parameters). The only difference being that its scopes are limited to the identified subpasses rather than potentially affecting everything before and after.

For attachments however, subpass dependencies work more like a VkImageMemoryBarrier defined similarly to the VkMemoryBarrier above, the queue family indices set to VK_QUEUE_FAMILY_IGNORED, and layouts as follows:

The equivalent to oldLayout is the attachment’s layout according to the subpass description for srcSubpass.
The equivalent to newLayout is the attachment’s layout according to the subpass description for dstSubpass.

Valid Usage

VUID-VkSubpassDependency-srcStageMask-00860
If the geometry shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
VUID-VkSubpassDependency-dstStageMask-00861
If the geometry shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
VUID-VkSubpassDependency-srcStageMask-00862
If the tessellation shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
VUID-VkSubpassDependency-dstStageMask-00863
If the tessellation shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
VUID-VkSubpassDependency-srcSubpass-00864
srcSubpass must be less than or equal to dstSubpass, unless one of them is VK_SUBPASS_EXTERNAL, to avoid cyclic dependencies and ensure a valid execution order
VUID-VkSubpassDependency-srcSubpass-00865
srcSubpass and dstSubpass must not both be equal to VK_SUBPASS_EXTERNAL
VUID-VkSubpassDependency-srcSubpass-00867
If srcSubpass is equal to dstSubpass and not all of the stages in srcStageMask and dstStageMask are framebuffer-space stages, the logically latest pipeline stage in srcStageMask must be logically earlier than or equal to the logically earliest pipeline stage in dstStageMask
VUID-VkSubpassDependency-srcAccessMask-00868
Any access flag included in srcAccessMask must be supported by one of the pipeline stages in srcStageMask, as specified in the table of supported access types
VUID-VkSubpassDependency-dstAccessMask-00869
Any access flag included in dstAccessMask must be supported by one of the pipeline stages in dstStageMask, as specified in the table of supported access types
VUID-VkSubpassDependency-srcSubpass-02243
If srcSubpass equals dstSubpass, and srcStageMask and dstStageMask both include a framebuffer-space stage, then dependencyFlags must include VK_DEPENDENCY_BY_REGION_BIT
VUID-VkSubpassDependency-dependencyFlags-02520
If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, srcSubpass must not be equal to VK_SUBPASS_EXTERNAL
VUID-VkSubpassDependency-dependencyFlags-02521
If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, dstSubpass must not be equal to VK_SUBPASS_EXTERNAL
VUID-VkSubpassDependency-srcSubpass-00872
If srcSubpass equals dstSubpass and that subpass has more than one bit set in the view mask, then dependencyFlags must include VK_DEPENDENCY_VIEW_LOCAL_BIT
VUID-VkSubpassDependency-srcStageMask-02099
If the mesh shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV
VUID-VkSubpassDependency-srcStageMask-02100
If the task shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV
VUID-VkSubpassDependency-dstStageMask-02101
If the mesh shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV
VUID-VkSubpassDependency-dstStageMask-02102
If the task shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV

Valid Usage (Implicit)

VUID-VkSubpassDependency-srcStageMask-parameter
srcStageMask must be a valid combination of VkPipelineStageFlagBits values
VUID-VkSubpassDependency-srcStageMask-requiredbitmask
srcStageMask must not be 0
VUID-VkSubpassDependency-dstStageMask-parameter
dstStageMask must be a valid combination of VkPipelineStageFlagBits values
VUID-VkSubpassDependency-dstStageMask-requiredbitmask
dstStageMask must not be 0
VUID-VkSubpassDependency-srcAccessMask-parameter
srcAccessMask must be a valid combination of VkAccessFlagBits values
VUID-VkSubpassDependency-dstAccessMask-parameter
dstAccessMask must be a valid combination of VkAccessFlagBits values
VUID-VkSubpassDependency-dependencyFlags-parameter
dependencyFlags must be a valid combination of VkDependencyFlagBits values

When multiview is enabled, the execution of the multiple views of one subpass may not occur simultaneously or even back-to-back, and rather may be interleaved with the execution of other subpasses. The load and store operations apply to attachments on a per-view basis. For example, an attachment using VK_ATTACHMENT_LOAD_OP_CLEAR will have each view cleared on first use, but the first use of one view may be temporally distant from the first use of another view.

Note

A good mental model for multiview is to think of a multiview subpass as if it were a collection of individual (per-view) subpasses that are logically grouped together and described as a single multiview subpass in the API. Similarly, a multiview attachment can be thought of like several individual attachments that happen to be layers in a single image. A view-local dependency between two multiview subpasses acts like a set of one-to-one dependencies between corresponding pairs of per-view subpasses. A view-global dependency between two multiview subpasses acts like a set of N × M dependencies between all pairs of per-view subpasses in the source and destination. Thus, it is a more compact representation which also makes clear the commonality and reuse that is present between views in a subpass. This interpretation motivates the answers to questions like “when does the load op apply” - it is on the first use of each view of an attachment, as if each view were a separate attachment.

If any two subpasses of a render pass activate transform feedback to the same bound transform feedback buffers, a subpass dependency must be included (either directly or via some intermediate subpasses) between them.

editing-note

The following two alleged implicit dependencies are practically no-ops, as the operations they describe are already guaranteed by semaphores and submission order (so they are almost entirely no-ops on their own). The only reason they exist is because it simplifies reasoning about where automatic layout transitions happen. Further rewrites of this chapter could potentially remove the need for these.

If there is no subpass dependency from VK_SUBPASS_EXTERNAL to the first subpass that uses an attachment, then an implicit subpass dependency exists from VK_SUBPASS_EXTERNAL to the first subpass it is used in. The subpass dependency operates as if defined with the following parameters:

VkSubpassDependency implicitDependency = {
    .srcSubpass = VK_SUBPASS_EXTERNAL;
    .dstSubpass = firstSubpass; // First subpass attachment is used in
    .srcStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
    .dstStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
    .srcAccessMask = 0;
    .dstAccessMask = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT |
                     VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
                     VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
                     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
                     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
    .dependencyFlags = 0;
};

Similarly, if there is no subpass dependency from the last subpass that uses an attachment to VK_SUBPASS_EXTERNAL, then an implicit subpass dependency exists from the last subpass it is used in to VK_SUBPASS_EXTERNAL. The subpass dependency operates as if defined with the following parameters:

VkSubpassDependency implicitDependency = {
    .srcSubpass = lastSubpass; // Last subpass attachment is used in
    .dstSubpass = VK_SUBPASS_EXTERNAL;
    .srcStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
    .dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
    .srcAccessMask = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT |
                     VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
                     VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
                     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
                     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
    .dstAccessMask = 0;
    .dependencyFlags = 0;
};

As subpasses may overlap or execute out of order with regards to other subpasses unless a subpass dependency chain describes otherwise, the layout transitions required between subpasses cannot be known to an application. Instead, an application provides the layout that each attachment must be in at the start and end of a render pass, and the layout it must be in during each subpass it is used in. The implementation then must execute layout transitions between subpasses in order to guarantee that the images are in the layouts required by each subpass, and in the final layout at the end of the render pass.

Automatic layout transitions apply to the entire image subresource attached to the framebuffer. If the attachment view is a 2D or 2D array view of a 3D image, even if the attachment view only refers to a subset of the slices of the selected mip level of the 3D image, automatic layout transitions apply to the entire subresource referenced which is the entire mip level in this case.

Automatic layout transitions away from the layout used in a subpass happen-after the availability operations for all dependencies with that subpass as the srcSubpass.

Automatic layout transitions into the layout used in a subpass happen-before the visibility operations for all dependencies with that subpass as the dstSubpass.

Automatic layout transitions away from initialLayout happens-after the availability operations for all dependencies with a srcSubpass equal to VK_SUBPASS_EXTERNAL, where dstSubpass uses the attachment that will be transitioned. For attachments created with VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT, automatic layout transitions away from initialLayout happen-after the availability operations for all dependencies with a srcSubpass equal to VK_SUBPASS_EXTERNAL, where dstSubpass uses any aliased attachment.

Automatic layout transitions into finalLayout happens-before the visibility operations for all dependencies with a dstSubpass equal to VK_SUBPASS_EXTERNAL, where srcSubpass uses the attachment that will be transitioned. For attachments created with VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT, automatic layout transitions into finalLayout happen-before the visibility operations for all dependencies with a dstSubpass equal to VK_SUBPASS_EXTERNAL, where srcSubpass uses any aliased attachment.

The image layout of the depth aspect of a depth/stencil attachment referring to an image created with VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT is dependent on the last sample locations used to render to the attachment, thus automatic layout transitions use the sample locations state specified in VkRenderPassSampleLocationsBeginInfoEXT.

Automatic layout transitions of an attachment referring to a depth/stencil image created with VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT use the sample locations the image subresource range referenced by the attachment was last rendered with. If the current render pass does not use the attachment as a depth/stencil attachment in any subpass that happens-before, the automatic layout transition uses the sample locations state specified in the sampleLocationsInfo member of the element of the VkRenderPassSampleLocationsBeginInfoEXT::pAttachmentInitialSampleLocations array for which the attachmentIndex member equals the attachment index of the attachment, if one is specified. Otherwise, the automatic layout transition uses the sample locations state specified in the sampleLocationsInfo member of the element of the VkRenderPassSampleLocationsBeginInfoEXT::pPostSubpassSampleLocations array for which the subpassIndex member equals the index of the subpass that last used the attachment as a depth/stencil attachment, if one is specified.

If no sample locations state has been specified for an automatic layout transition performed on an attachment referring to a depth/stencil image created with VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT the contents of the depth aspect of the depth/stencil attachment become undefined as if the layout of the attachment was transitioned from the VK_IMAGE_LAYOUT_UNDEFINED layout.

If two subpasses use the same attachment, and both subpasses use the attachment in a read-only layout, no subpass dependency needs to be specified between those subpasses. If an implementation treats those layouts separately, it must insert an implicit subpass dependency between those subpasses to separate the uses in each layout. The subpass dependency operates as if defined with the following parameters:

// Used for input attachments
VkPipelineStageFlags inputAttachmentStages = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
VkAccessFlags inputAttachmentAccess = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;

// Used for depth/stencil attachments
VkPipelineStageFlags depthStencilAttachmentStages = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
VkAccessFlags depthStencilAttachmentAccess = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;

VkSubpassDependency implicitDependency = {
    .srcSubpass = firstSubpass;
    .dstSubpass = secondSubpass;
    .srcStageMask = inputAttachmentStages | depthStencilAttachmentStages;
    .dstStageMask = inputAttachmentStages | depthStencilAttachmentStages;
    .srcAccessMask = inputAttachmentAccess | depthStencilAttachmentAccess;
    .dstAccessMask = inputAttachmentAccess | depthStencilAttachmentAccess;
    .dependencyFlags = 0;
};

If a subpass uses the same attachment as both an input attachment and either a color attachment or a depth/stencil attachment, writes via the color or depth/stencil attachment are not automatically made visible to reads via the input attachment, causing a feedback loop, except in any of the following conditions:

If the color components or depth/stencil components read by the input attachment are mutually exclusive with the components written by the color or depth/stencil attachments, then there is no feedback loop. This requires the graphics pipelines used by the subpass to disable writes to color components that are read as inputs via the colorWriteMask, and to disable writes to depth/stencil components that are read as inputs via depthWriteEnable or stencilTestEnable.
If the attachment is used as an input attachment and depth/stencil attachment only, and the depth/stencil attachment is not written to.
If a memory dependency is inserted between when the attachment is written and when it is subsequently read by later fragments. Pipeline barriers expressing a subpass self-dependency are the only way to achieve this, and one must be inserted every time a fragment will read values at a particular sample (x, y, layer, sample) coordinate, if those values have been written since the most recent pipeline barrier; or the since start of the subpass if there have been no pipeline barriers since the start of the subpass.

An attachment used as both an input attachment and a color attachment must be in the VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR or VK_IMAGE_LAYOUT_GENERAL layout. An attachment used as an input attachment and depth/stencil attachment must be in the VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_GENERAL layout. An attachment must not be used as both a depth/stencil attachment and a color attachment.

A more extensible version of render pass creation is also defined below.

To create a render pass, call:

VkResult vkCreateRenderPass2(
    VkDevice                                    device,
    const VkRenderPassCreateInfo2*              pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkRenderPass*                               pRenderPass);

or the equivalent command

VkResult vkCreateRenderPass2KHR(
    VkDevice                                    device,
    const VkRenderPassCreateInfo2*              pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkRenderPass*                               pRenderPass);

device is the logical device that creates the render pass.
pCreateInfo is a pointer to a VkRenderPassCreateInfo2 structure describing the parameters of the render pass.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pRenderPass is a pointer to a VkRenderPass handle in which the resulting render pass object is returned.

This command is functionally identical to vkCreateRenderPass, but includes extensible sub-structures that include sType and pNext parameters, allowing them to be more easily extended.

Valid Usage (Implicit)

VUID-vkCreateRenderPass2-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateRenderPass2-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkRenderPassCreateInfo2 structure
VUID-vkCreateRenderPass2-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateRenderPass2-pRenderPass-parameter
pRenderPass must be a valid pointer to a VkRenderPass handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkRenderPassCreateInfo2 structure is defined as:

typedef struct VkRenderPassCreateInfo2 {
    VkStructureType                    sType;
    const void*                        pNext;
    VkRenderPassCreateFlags            flags;
    uint32_t                           attachmentCount;
    const VkAttachmentDescription2*    pAttachments;
    uint32_t                           subpassCount;
    const VkSubpassDescription2*       pSubpasses;
    uint32_t                           dependencyCount;
    const VkSubpassDependency2*        pDependencies;
    uint32_t                           correlatedViewMaskCount;
    const uint32_t*                    pCorrelatedViewMasks;
} VkRenderPassCreateInfo2;

or the equivalent

typedef VkRenderPassCreateInfo2 VkRenderPassCreateInfo2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
attachmentCount is the number of attachments used by this render pass.
pAttachments is a pointer to an array of attachmentCount VkAttachmentDescription2 structures describing the attachments used by the render pass.
subpassCount is the number of subpasses to create.
pSubpasses is a pointer to an array of subpassCount VkSubpassDescription2 structures describing each subpass.
dependencyCount is the number of dependencies between pairs of subpasses.
pDependencies is a pointer to an array of dependencyCount VkSubpassDependency structures describing dependencies between pairs of subpasses.
correlatedViewMaskCount is the number of correlation masks.
pCorrelatedViewMasks is a pointer to an array of view masks indicating sets of views that may be more efficient to render concurrently.

Parameters defined by this structure with the same name as those in VkRenderPassCreateInfo have the identical effect to those parameters; the child structures are variants of those used in VkRenderPassCreateInfo which add sType and pNext parameters, allowing them to be extended.

If the VkSubpassDescription2::viewMask member of any element of pSubpasses is not zero, multiview functionality is considered to be enabled for this render pass.

correlatedViewMaskCount and pCorrelatedViewMasks have the same effect as VkRenderPassMultiviewCreateInfo::correlationMaskCount and VkRenderPassMultiviewCreateInfo::pCorrelationMasks, respectively.

Valid Usage

VUID-VkRenderPassCreateInfo2-None-03049
If any two subpasses operate on attachments with overlapping ranges of the same VkDeviceMemory object, and at least one subpass writes to that area of VkDeviceMemory, a subpass dependency must be included (either directly or via some intermediate subpasses) between them
VUID-VkRenderPassCreateInfo2-attachment-03050
If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or the attachment indexed by any element of pPreserveAttachments in any given element of pSubpasses is bound to a range of a VkDeviceMemory object that overlaps with any other attachment in any subpass (including the same subpass), the VkAttachmentDescription2 structures describing them must include VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT in flags
VUID-VkRenderPassCreateInfo2-attachment-03051
If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or any element of pPreserveAttachments in any given element of pSubpasses is not VK_ATTACHMENT_UNUSED, it must be less than attachmentCount
VUID-VkRenderPassCreateInfo2-pAttachments-02522
For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
VUID-VkRenderPassCreateInfo2-pAttachments-02523
For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL.
VUID-VkRenderPassCreateInfo2-pDependencies-03054
For any element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass
VUID-VkRenderPassCreateInfo2-pDependencies-03055
For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the destination subpass
VUID-VkRenderPassCreateInfo2-pCorrelatedViewMasks-03056
The set of bits included in any element of pCorrelatedViewMasks must not overlap with the set of bits included in any other element of pCorrelatedViewMasks
VUID-VkRenderPassCreateInfo2-viewMask-03057
If the VkSubpassDescription2::viewMask member of all elements of pSubpasses is 0, correlatedViewMaskCount must be 0
VUID-VkRenderPassCreateInfo2-viewMask-03058
The VkSubpassDescription2::viewMask member of all elements of pSubpasses must either all be 0, or all not be 0
VUID-VkRenderPassCreateInfo2-viewMask-03059
If the VkSubpassDescription2::viewMask member of all elements of pSubpasses is 0, the dependencyFlags member of any element of pDependencies must not include VK_DEPENDENCY_VIEW_LOCAL_BIT
VUID-VkRenderPassCreateInfo2-pDependencies-03060
For any element of pDependencies where its srcSubpass member equals its dstSubpass member, if the viewMask member of the corresponding element of pSubpasses includes more than one bit, its dependencyFlags member must include VK_DEPENDENCY_VIEW_LOCAL_BIT
VUID-VkRenderPassCreateInfo2-viewMask-02524
The viewMask member must not have a bit set at an index greater than or equal to VkPhysicalDeviceLimits::maxFramebufferLayers
VUID-VkRenderPassCreateInfo2-attachment-02525
If the attachment member of any element of the pInputAttachments member of any element of pSubpasses is not VK_ATTACHMENT_UNUSED, the aspectMask member of that element of pInputAttachments must only include aspects that are present in images of the format specified by the element of pAttachments specified by attachment
VUID-VkRenderPassCreateInfo2-srcSubpass-02526
The srcSubpass member of each element of pDependencies must be less than subpassCount
VUID-VkRenderPassCreateInfo2-dstSubpass-02527
The dstSubpass member of each element of pDependencies must be less than subpassCount

Valid Usage (Implicit)

VUID-VkRenderPassCreateInfo2-sType-sType
sType must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2
VUID-VkRenderPassCreateInfo2-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkRenderPassFragmentDensityMapCreateInfoEXT
VUID-VkRenderPassCreateInfo2-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkRenderPassCreateInfo2-flags-zerobitmask
flags must be 0
VUID-VkRenderPassCreateInfo2-pAttachments-parameter
If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription2 structures
VUID-VkRenderPassCreateInfo2-pSubpasses-parameter
pSubpasses must be a valid pointer to an array of subpassCount valid VkSubpassDescription2 structures
VUID-VkRenderPassCreateInfo2-pDependencies-parameter
If dependencyCount is not 0, pDependencies must be a valid pointer to an array of dependencyCount valid VkSubpassDependency2 structures
VUID-VkRenderPassCreateInfo2-pCorrelatedViewMasks-parameter
If correlatedViewMaskCount is not 0, pCorrelatedViewMasks must be a valid pointer to an array of correlatedViewMaskCount uint32_t values
VUID-VkRenderPassCreateInfo2-subpassCount-arraylength
subpassCount must be greater than 0

The VkAttachmentDescription2 structure is defined as:

typedef struct VkAttachmentDescription2 {
    VkStructureType                 sType;
    const void*                     pNext;
    VkAttachmentDescriptionFlags    flags;
    VkFormat                        format;
    VkSampleCountFlagBits           samples;
    VkAttachmentLoadOp              loadOp;
    VkAttachmentStoreOp             storeOp;
    VkAttachmentLoadOp              stencilLoadOp;
    VkAttachmentStoreOp             stencilStoreOp;
    VkImageLayout                   initialLayout;
    VkImageLayout                   finalLayout;
} VkAttachmentDescription2;

or the equivalent

typedef VkAttachmentDescription2 VkAttachmentDescription2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkAttachmentDescriptionFlagBits specifying additional properties of the attachment.
format is a VkFormat value specifying the format of the image that will be used for the attachment.
samples is the number of samples of the image as defined in VkSampleCountFlagBits.
loadOp is a VkAttachmentLoadOp value specifying how the contents of color and depth components of the attachment are treated at the beginning of the subpass where it is first used.
storeOp is a VkAttachmentStoreOp value specifying how the contents of color and depth components of the attachment are treated at the end of the subpass where it is last used.
stencilLoadOp is a VkAttachmentLoadOp value specifying how the contents of stencil components of the attachment are treated at the beginning of the subpass where it is first used.
stencilStoreOp is a VkAttachmentStoreOp value specifying how the contents of stencil components of the attachment are treated at the end of the last subpass where it is used.
initialLayout is the layout the attachment image subresource will be in when a render pass instance begins.
finalLayout is the layout the attachment image subresource will be transitioned to when a render pass instance ends.

Parameters defined by this structure with the same name as those in VkAttachmentDescription have the identical effect to those parameters.

If the separateDepthStencilLayouts feature is enabled, and format is a depth/stencil format, initialLayout and finalLayout can be set to a layout that only specifies the layout of the depth aspect.

If format is a depth/stencil format, and initialLayout only specifies the initial layout of the depth aspect of the attachment, the initial layout of the stencil aspect is specified by the stencilInitialLayout member of a VkAttachmentDescriptionStencilLayout structure included in the pNext chain. Otherwise, initialLayout describes the initial layout for all relevant image aspects.

If format is a depth/stencil format, and finalLayout only specifies the final layout of the depth aspect of the attachment, the final layout of the stencil aspect is specified by the stencilFinalLayout member of a VkAttachmentDescriptionStencilLayout structure included in the pNext chain. Otherwise, finalLayout describes the final layout for all relevant image aspects.

Valid Usage

VUID-VkAttachmentDescription2-finalLayout-03061
finalLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED
VUID-VkAttachmentDescription2-format-03294
If format is a color format, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
VUID-VkAttachmentDescription2-format-03295
If format is a depth/stencil format, initialLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
VUID-VkAttachmentDescription2-format-03296
If format is a color format, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
VUID-VkAttachmentDescription2-format-03297
If format is a depth/stencil format, finalLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
VUID-VkAttachmentDescription2-separateDepthStencilLayouts-03298
If the separateDepthStencilLayouts feature is not enabled, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL
VUID-VkAttachmentDescription2-separateDepthStencilLayouts-03299
If the separateDepthStencilLayouts feature is not enabled, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL
VUID-VkAttachmentDescription2-format-03300
If format is a color format, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL
VUID-VkAttachmentDescription2-format-03301
If format is a color format, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL
VUID-VkAttachmentDescription2-format-03302
If format is a depth/stencil format which includes both depth and stencil aspects, and initialLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, the pNext chain must include a VkAttachmentDescriptionStencilLayout structure
VUID-VkAttachmentDescription2-format-03303
If format is a depth/stencil format which includes both depth and stencil aspects, and finalLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, the pNext chain must include a VkAttachmentDescriptionStencilLayout structure
VUID-VkAttachmentDescription2-format-03304
If format is a depth/stencil format which includes only the depth aspect, initialLayout must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL
VUID-VkAttachmentDescription2-format-03305
If format is a depth/stencil format which includes only the depth aspect, finalLayout must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL
VUID-VkAttachmentDescription2-format-03306
If format is a depth/stencil format which includes only the stencil aspect, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL
VUID-VkAttachmentDescription2-format-03307
If format is a depth/stencil format which includes only the stencil aspect, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL

Valid Usage (Implicit)

VUID-VkAttachmentDescription2-sType-sType
sType must be VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2
VUID-VkAttachmentDescription2-flags-parameter
flags must be a valid combination of VkAttachmentDescriptionFlagBits values
VUID-VkAttachmentDescription2-format-parameter
format must be a valid VkFormat value
VUID-VkAttachmentDescription2-samples-parameter
samples must be a valid VkSampleCountFlagBits value
VUID-VkAttachmentDescription2-loadOp-parameter
loadOp must be a valid VkAttachmentLoadOp value
VUID-VkAttachmentDescription2-storeOp-parameter
storeOp must be a valid VkAttachmentStoreOp value
VUID-VkAttachmentDescription2-stencilLoadOp-parameter
stencilLoadOp must be a valid VkAttachmentLoadOp value
VUID-VkAttachmentDescription2-stencilStoreOp-parameter
stencilStoreOp must be a valid VkAttachmentStoreOp value
VUID-VkAttachmentDescription2-initialLayout-parameter
initialLayout must be a valid VkImageLayout value
VUID-VkAttachmentDescription2-finalLayout-parameter
finalLayout must be a valid VkImageLayout value

The VkAttachmentDescriptionStencilLayout structure is defined as:

typedef struct VkAttachmentDescriptionStencilLayout {
    VkStructureType    sType;
    void*              pNext;
    VkImageLayout      stencilInitialLayout;
    VkImageLayout      stencilFinalLayout;
} VkAttachmentDescriptionStencilLayout;

or the equivalent

typedef VkAttachmentDescriptionStencilLayout VkAttachmentDescriptionStencilLayoutKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
stencilInitialLayout is the layout the stencil aspect of the attachment image subresource will be in when a render pass instance begins.
stencilFinalLayout is the layout the stencil aspect of the attachment image subresource will be transitioned to when a render pass instance ends.

Valid Usage

VUID-VkAttachmentDescriptionStencilLayout-stencilInitialLayout-03308
stencilInitialLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
VUID-VkAttachmentDescriptionStencilLayout-stencilFinalLayout-03309
stencilFinalLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
VUID-VkAttachmentDescriptionStencilLayout-stencilFinalLayout-03310
stencilFinalLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED

Valid Usage (Implicit)

VUID-VkAttachmentDescriptionStencilLayout-sType-sType
sType must be VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT
VUID-VkAttachmentDescriptionStencilLayout-stencilInitialLayout-parameter
stencilInitialLayout must be a valid VkImageLayout value
VUID-VkAttachmentDescriptionStencilLayout-stencilFinalLayout-parameter
stencilFinalLayout must be a valid VkImageLayout value

The VkSubpassDescription2 structure is defined as:

typedef struct VkSubpassDescription2 {
    VkStructureType                  sType;
    const void*                      pNext;
    VkSubpassDescriptionFlags        flags;
    VkPipelineBindPoint              pipelineBindPoint;
    uint32_t                         viewMask;
    uint32_t                         inputAttachmentCount;
    const VkAttachmentReference2*    pInputAttachments;
    uint32_t                         colorAttachmentCount;
    const VkAttachmentReference2*    pColorAttachments;
    const VkAttachmentReference2*    pResolveAttachments;
    const VkAttachmentReference2*    pDepthStencilAttachment;
    uint32_t                         preserveAttachmentCount;
    const uint32_t*                  pPreserveAttachments;
} VkSubpassDescription2;

or the equivalent

typedef VkSubpassDescription2 VkSubpassDescription2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkSubpassDescriptionFlagBits specifying usage of the subpass.
pipelineBindPoint is a VkPipelineBindPoint value specifying the pipeline type supported for this subpass.
viewMask is a bitfield of view indices describing which views rendering is broadcast to in this subpass, when multiview is enabled.
inputAttachmentCount is the number of input attachments.
pInputAttachments is a pointer to an array of VkAttachmentReference2 structures defining the input attachments for this subpass and their layouts.
colorAttachmentCount is the number of color attachments.
pColorAttachments is a pointer to an array of VkAttachmentReference2 structures defining the color attachments for this subpass and their layouts.
pResolveAttachments is an optional array of colorAttachmentCount VkAttachmentReference2 structures defining the resolve attachments for this subpass and their layouts.
pDepthStencilAttachment is a pointer to a VkAttachmentReference2 structure specifying the depth/stencil attachment for this subpass and its layout.
preserveAttachmentCount is the number of preserved attachments.
pPreserveAttachments is a pointer to an array of preserveAttachmentCount render pass attachment indices identifying attachments that are not used by this subpass, but whose contents must be preserved throughout the subpass.

Parameters defined by this structure with the same name as those in VkSubpassDescription have the identical effect to those parameters.

viewMask has the same effect for the described subpass as VkRenderPassMultiviewCreateInfo::pViewMasks has on each corresponding subpass.

Valid Usage

VUID-VkSubpassDescription2-pipelineBindPoint-03062
pipelineBindPoint must be VK_PIPELINE_BIND_POINT_GRAPHICS
VUID-VkSubpassDescription2-colorAttachmentCount-03063
colorAttachmentCount must be less than or equal to VkPhysicalDeviceLimits::maxColorAttachments
VUID-VkSubpassDescription2-loadOp-03064
If the first use of an attachment in this render pass is as an input attachment, and the attachment is not also used as a color or depth/stencil attachment in the same subpass, then loadOp must not be VK_ATTACHMENT_LOAD_OP_CLEAR
VUID-VkSubpassDescription2-pResolveAttachments-03065
If pResolveAttachments is not NULL, for each resolve attachment that does not have the value VK_ATTACHMENT_UNUSED, the corresponding color attachment must not have the value VK_ATTACHMENT_UNUSED
VUID-VkSubpassDescription2-pResolveAttachments-03066
If pResolveAttachments is not NULL, for each resolve attachment that is not VK_ATTACHMENT_UNUSED, the corresponding color attachment must not have a sample count of VK_SAMPLE_COUNT_1_BIT
VUID-VkSubpassDescription2-pResolveAttachments-03067
If pResolveAttachments is not NULL, each resolve attachment that is not VK_ATTACHMENT_UNUSED must have a sample count of VK_SAMPLE_COUNT_1_BIT
VUID-VkSubpassDescription2-pResolveAttachments-03068
Any given element of pResolveAttachments must have the same VkFormat as its corresponding color attachment
VUID-VkSubpassDescription2-pColorAttachments-03069
All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have the same sample count
VUID-VkSubpassDescription2-pColorAttachments-03070
If the VK_AMD_mixed_attachment_samples extension is enabled, all attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have a sample count that is smaller than or equal to the sample count of pDepthStencilAttachment if it is not VK_ATTACHMENT_UNUSED
VUID-VkSubpassDescription2-pDepthStencilAttachment-03071
If neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, and if pDepthStencilAttachment is not VK_ATTACHMENT_UNUSED and any attachments in pColorAttachments are not VK_ATTACHMENT_UNUSED, they must have the same sample count
VUID-VkSubpassDescription2-attachment-03073
The attachment member of any element of pPreserveAttachments must not be VK_ATTACHMENT_UNUSED
VUID-VkSubpassDescription2-pPreserveAttachments-03074
Any given element of pPreserveAttachments must not also be an element of any other member of the subpass description
VUID-VkSubpassDescription2-layout-02528
If any attachment is used by more than one VkAttachmentReference member, then each use must use the same layout
VUID-VkSubpassDescription2-flags-03076
If flags includes VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX, it must also include VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX.
VUID-VkSubpassDescription2-attachment-02799
If the attachment member of any element of pInputAttachments is not VK_ATTACHMENT_UNUSED, then the aspectMask member must be a valid combination of VkImageAspectFlagBits
VUID-VkSubpassDescription2-attachment-02800
If the attachment member of any element of pInputAttachments is not VK_ATTACHMENT_UNUSED, then the aspectMask member must not be 0
VUID-VkSubpassDescription2-attachment-02801
If the attachment member of any element of pInputAttachments is not VK_ATTACHMENT_UNUSED, then the aspectMask member must not include VK_IMAGE_ASPECT_METADATA_BIT

Valid Usage (Implicit)

VUID-VkSubpassDescription2-sType-sType
sType must be VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2
VUID-VkSubpassDescription2-flags-parameter
flags must be a valid combination of VkSubpassDescriptionFlagBits values
VUID-VkSubpassDescription2-pipelineBindPoint-parameter
pipelineBindPoint must be a valid VkPipelineBindPoint value
VUID-VkSubpassDescription2-pInputAttachments-parameter
If inputAttachmentCount is not 0, pInputAttachments must be a valid pointer to an array of inputAttachmentCount valid VkAttachmentReference2 structures
VUID-VkSubpassDescription2-pColorAttachments-parameter
If colorAttachmentCount is not 0, pColorAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference2 structures
VUID-VkSubpassDescription2-pResolveAttachments-parameter
If colorAttachmentCount is not 0, and pResolveAttachments is not NULL, pResolveAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference2 structures
VUID-VkSubpassDescription2-pDepthStencilAttachment-parameter
If pDepthStencilAttachment is not NULL, pDepthStencilAttachment must be a valid pointer to a valid VkAttachmentReference2 structure
VUID-VkSubpassDescription2-pPreserveAttachments-parameter
If preserveAttachmentCount is not 0, pPreserveAttachments must be a valid pointer to an array of preserveAttachmentCount uint32_t values

If the pNext list of VkSubpassDescription2 includes a VkSubpassDescriptionDepthStencilResolve structure, then that structure describes multisample resolve operations for the depth/stencil attachment in a subpass.

The VkSubpassDescriptionDepthStencilResolve structure is defined as:

typedef struct VkSubpassDescriptionDepthStencilResolve {
    VkStructureType                  sType;
    const void*                      pNext;
    VkResolveModeFlagBits            depthResolveMode;
    VkResolveModeFlagBits            stencilResolveMode;
    const VkAttachmentReference2*    pDepthStencilResolveAttachment;
} VkSubpassDescriptionDepthStencilResolve;

or the equivalent

typedef VkSubpassDescriptionDepthStencilResolve VkSubpassDescriptionDepthStencilResolveKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
depthResolveMode is a bitmask of VkResolveModeFlagBits describing the depth resolve mode.
stencilResolveMode is a bitmask of VkResolveModeFlagBits describing the stencil resolve mode.
pDepthStencilResolveAttachment is an optional VkAttachmentReference structure defining the depth/stencil resolve attachment for this subpass and its layout.

Valid Usage

VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03177
If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED, pDepthStencilAttachment must not have the value VK_ATTACHMENT_UNUSED
VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03178
If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED, depthResolveMode and stencilResolveMode must not both be VK_RESOLVE_MODE_NONE
VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03179
If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED, pDepthStencilAttachment must not have a sample count of VK_SAMPLE_COUNT_1_BIT
VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03180
If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED, pDepthStencilResolveAttachment must have a sample count of VK_SAMPLE_COUNT_1_BIT
VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-02651
If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED then it must have a format whose features contain VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03181
If the VkFormat of pDepthStencilResolveAttachment has a depth component, then the VkFormat of pDepthStencilAttachment must have a depth component with the same number of bits and numerical type
VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03182
If the VkFormat of pDepthStencilResolveAttachment has a stencil component, then the VkFormat of pDepthStencilAttachment must have a stencil component with the same number of bits and numerical type
VUID-VkSubpassDescriptionDepthStencilResolve-depthResolveMode-03183
The value of depthResolveMode must be one of the bits set in VkPhysicalDeviceDepthStencilResolveProperties::supportedDepthResolveModes or VK_RESOLVE_MODE_NONE
VUID-VkSubpassDescriptionDepthStencilResolve-stencilResolveMode-03184
The value of stencilResolveMode must be one of the bits set in VkPhysicalDeviceDepthStencilResolveProperties::supportedStencilResolveModes or VK_RESOLVE_MODE_NONE
VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03185
If the VkFormat of pDepthStencilResolveAttachment has both depth and stencil components, VkPhysicalDeviceDepthStencilResolveProperties::independentResolve is VK_FALSE, and VkPhysicalDeviceDepthStencilResolveProperties::independentResolveNone is VK_FALSE, then the values of depthResolveMode and stencilResolveMode must be identical
VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03186
If the VkFormat of pDepthStencilResolveAttachment has both depth and stencil components, VkPhysicalDeviceDepthStencilResolveProperties::independentResolve is VK_FALSE and VkPhysicalDeviceDepthStencilResolveProperties::independentResolveNone is VK_TRUE, then the values of depthResolveMode and stencilResolveMode must be identical or one of them must be VK_RESOLVE_MODE_NONE

Valid Usage (Implicit)

VUID-VkSubpassDescriptionDepthStencilResolve-sType-sType
sType must be VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE
VUID-VkSubpassDescriptionDepthStencilResolve-depthResolveMode-parameter
depthResolveMode must be a valid VkResolveModeFlagBits value
VUID-VkSubpassDescriptionDepthStencilResolve-stencilResolveMode-parameter
stencilResolveMode must be a valid VkResolveModeFlagBits value
VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-parameter
If pDepthStencilResolveAttachment is not NULL, pDepthStencilResolveAttachment must be a valid pointer to a valid VkAttachmentReference2 structure

Possible values of VkSubpassDescriptionDepthStencilResolve::depthResolveMode and stencilResolveMode, specifying the depth and stencil resolve modes, are:

typedef enum VkResolveModeFlagBits {
    VK_RESOLVE_MODE_NONE = 0,
    VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 0x00000001,
    VK_RESOLVE_MODE_AVERAGE_BIT = 0x00000002,
    VK_RESOLVE_MODE_MIN_BIT = 0x00000004,
    VK_RESOLVE_MODE_MAX_BIT = 0x00000008,
    VK_RESOLVE_MODE_NONE_KHR = VK_RESOLVE_MODE_NONE,
    VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
    VK_RESOLVE_MODE_AVERAGE_BIT_KHR = VK_RESOLVE_MODE_AVERAGE_BIT,
    VK_RESOLVE_MODE_MIN_BIT_KHR = VK_RESOLVE_MODE_MIN_BIT,
    VK_RESOLVE_MODE_MAX_BIT_KHR = VK_RESOLVE_MODE_MAX_BIT,
    VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkResolveModeFlagBits;

or the equivalent

typedef VkResolveModeFlagBits VkResolveModeFlagBitsKHR;

VK_RESOLVE_MODE_NONE indicates that no resolve operation is done.
VK_RESOLVE_MODE_SAMPLE_ZERO_BIT indicates that result of the resolve operation is equal to the value of sample 0.
VK_RESOLVE_MODE_AVERAGE_BIT indicates that result of the resolve operation is the average of the sample values.
VK_RESOLVE_MODE_MIN_BIT indicates that result of the resolve operation is the minimum of the sample values.
VK_RESOLVE_MODE_MAX_BIT indicates that result of the resolve operation is the maximum of the sample values.

typedef VkFlags VkResolveModeFlags;

or the equivalent

typedef VkResolveModeFlags VkResolveModeFlagsKHR;

VkResolveModeFlags is a bitmask type for setting a mask of zero or more VkResolveModeFlagBits.

The VkAttachmentReference2 structure is defined as:

typedef struct VkAttachmentReference2 {
    VkStructureType       sType;
    const void*           pNext;
    uint32_t              attachment;
    VkImageLayout         layout;
    VkImageAspectFlags    aspectMask;
} VkAttachmentReference2;

or the equivalent

typedef VkAttachmentReference2 VkAttachmentReference2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
attachment is either an integer value identifying an attachment at the corresponding index in VkRenderPassCreateInfo::pAttachments, or VK_ATTACHMENT_UNUSED to signify that this attachment is not used.
layout is a VkImageLayout value specifying the layout the attachment uses during the subpass.
aspectMask is a mask of which aspect(s) can be accessed within the specified subpass as an input attachment.

Parameters defined by this structure with the same name as those in VkAttachmentReference have the identical effect to those parameters.

aspectMask has the same effect for the described attachment as VkInputAttachmentAspectReference::aspectMask has on each corresponding attachment. It is ignored when this structure is used to describe anything other than an input attachment reference.

If the separateDepthStencilLayouts feature is enabled, and attachment has a depth/stencil format, layout can be set to a layout that only specifies the layout of the depth aspect.

If layout only specifies the layout of the depth aspect of the attachment, the layout of the stencil aspect is specified by the stencilLayout member of a VkAttachmentReferenceStencilLayout structure included in the pNext chain. Otherwise, layout describes the layout for all relevant image aspects.

Valid Usage

VUID-VkAttachmentReference2-layout-03077
If attachment is not VK_ATTACHMENT_UNUSED, layout must not be VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PREINITIALIZED, or VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
VUID-VkAttachmentReference2-attachment-03311
If attachment is not VK_ATTACHMENT_UNUSED, and aspectMask does not include VK_IMAGE_ASPECT_STENCIL_BIT or VK_IMAGE_ASPECT_DEPTH_BIT, layout must not be VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
VUID-VkAttachmentReference2-attachment-03312
If attachment is not VK_ATTACHMENT_UNUSED, and aspectMask does not include VK_IMAGE_ASPECT_COLOR_BIT, layout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
VUID-VkAttachmentReference2-separateDepthStencilLayouts-03313
If the separateDepthStencilLayouts feature is not enabled, and attachment is not VK_ATTACHMENT_UNUSED, layout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL,
VUID-VkAttachmentReference2-attachment-03314
If attachment is not VK_ATTACHMENT_UNUSED, and aspectMask includes VK_IMAGE_ASPECT_COLOR_BIT, layout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL,
VUID-VkAttachmentReference2-attachment-03315
If attachment is not VK_ATTACHMENT_UNUSED, and aspectMask includes both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT, and layout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, the pNext chain must include a VkAttachmentReferenceStencilLayout structure
VUID-VkAttachmentReference2-attachment-03316
If attachment is not VK_ATTACHMENT_UNUSED, and aspectMask includes only VK_IMAGE_ASPECT_DEPTH_BIT then layout must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL
VUID-VkAttachmentReference2-attachment-03317
If attachment is not VK_ATTACHMENT_UNUSED, and aspectMask includes only VK_IMAGE_ASPECT_STENCIL_BIT then layout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL

Valid Usage (Implicit)

VUID-VkAttachmentReference2-sType-sType
sType must be VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2
VUID-VkAttachmentReference2-layout-parameter
layout must be a valid VkImageLayout value

The VkAttachmentReferenceStencilLayout structure is defined as:

typedef struct VkAttachmentReferenceStencilLayout {
    VkStructureType    sType;
    void*              pNext;
    VkImageLayout      stencilLayout;
} VkAttachmentReferenceStencilLayout;

or the equivalent

typedef VkAttachmentReferenceStencilLayout VkAttachmentReferenceStencilLayoutKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
stencilLayout is a VkImageLayout value specifying the layout the stencil aspect of the attachment uses during the subpass.

Valid Usage

VUID-VkAttachmentReferenceStencilLayout-stencilLayout-03318
stencilLayout must not be VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PREINITIALIZED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_PRESENT_SRC_KHR

Valid Usage (Implicit)

VUID-VkAttachmentReferenceStencilLayout-sType-sType
sType must be VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT
VUID-VkAttachmentReferenceStencilLayout-stencilLayout-parameter
stencilLayout must be a valid VkImageLayout value

The VkSubpassDependency2 structure is defined as:

typedef struct VkSubpassDependency2 {
    VkStructureType         sType;
    const void*             pNext;
    uint32_t                srcSubpass;
    uint32_t                dstSubpass;
    VkPipelineStageFlags    srcStageMask;
    VkPipelineStageFlags    dstStageMask;
    VkAccessFlags           srcAccessMask;
    VkAccessFlags           dstAccessMask;
    VkDependencyFlags       dependencyFlags;
    int32_t                 viewOffset;
} VkSubpassDependency2;

or the equivalent

typedef VkSubpassDependency2 VkSubpassDependency2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
srcSubpass is the subpass index of the first subpass in the dependency, or VK_SUBPASS_EXTERNAL.
dstSubpass is the subpass index of the second subpass in the dependency, or VK_SUBPASS_EXTERNAL.
srcStageMask is a bitmask of VkPipelineStageFlagBits specifying the source stage mask.
dstStageMask is a bitmask of VkPipelineStageFlagBits specifying the destination stage mask
srcAccessMask is a bitmask of VkAccessFlagBits specifying a source access mask.
dstAccessMask is a bitmask of VkAccessFlagBits specifying a destination access mask.
dependencyFlags is a bitmask of VkDependencyFlagBits.
viewOffset controls which views in the source subpass the views in the destination subpass depend on.

Parameters defined by this structure with the same name as those in VkSubpassDependency have the identical effect to those parameters.

viewOffset has the same effect for the described subpass dependency as VkRenderPassMultiviewCreateInfo::pViewOffsets has on each corresponding subpass dependency.

Valid Usage

VUID-VkSubpassDependency2-srcStageMask-03080
If the geometry shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
VUID-VkSubpassDependency2-dstStageMask-03081
If the geometry shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
VUID-VkSubpassDependency2-srcStageMask-03082
If the tessellation shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
VUID-VkSubpassDependency2-dstStageMask-03083
If the tessellation shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
VUID-VkSubpassDependency2-srcSubpass-03084
srcSubpass must be less than or equal to dstSubpass, unless one of them is VK_SUBPASS_EXTERNAL, to avoid cyclic dependencies and ensure a valid execution order
VUID-VkSubpassDependency2-srcSubpass-03085
srcSubpass and dstSubpass must not both be equal to VK_SUBPASS_EXTERNAL
VUID-VkSubpassDependency2-srcSubpass-03087
If srcSubpass is equal to dstSubpass and not all of the stages in srcStageMask and dstStageMask are framebuffer-space stages, the logically latest pipeline stage in srcStageMask must be logically earlier than or equal to the logically earliest pipeline stage in dstStageMask
VUID-VkSubpassDependency2-srcAccessMask-03088
Any access flag included in srcAccessMask must be supported by one of the pipeline stages in srcStageMask, as specified in the table of supported access types
VUID-VkSubpassDependency2-dstAccessMask-03089
Any access flag included in dstAccessMask must be supported by one of the pipeline stages in dstStageMask, as specified in the table of supported access types
VUID-VkSubpassDependency2-dependencyFlags-03090
If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, srcSubpass must not be equal to VK_SUBPASS_EXTERNAL
VUID-VkSubpassDependency2-dependencyFlags-03091
If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, dstSubpass must not be equal to VK_SUBPASS_EXTERNAL
VUID-VkSubpassDependency2-srcSubpass-02245
If srcSubpass equals dstSubpass, and srcStageMask and dstStageMask both include a framebuffer-space stage, then dependencyFlags must include VK_DEPENDENCY_BY_REGION_BIT
VUID-VkSubpassDependency2-viewOffset-02530
If viewOffset is not equal to 0, srcSubpass must not be equal to dstSubpass
VUID-VkSubpassDependency2-dependencyFlags-03092
If dependencyFlags does not include VK_DEPENDENCY_VIEW_LOCAL_BIT, viewOffset must be 0
VUID-VkSubpassDependency2-viewOffset-03093
If viewOffset is not 0, srcSubpass must not be equal to dstSubpass.
VUID-VkSubpassDependency2-srcStageMask-02103
If the mesh shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV
VUID-VkSubpassDependency2-srcStageMask-02104
If the task shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV
VUID-VkSubpassDependency2-dstStageMask-02105
If the mesh shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV
VUID-VkSubpassDependency2-dstStageMask-02106
If the task shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV

Valid Usage (Implicit)

VUID-VkSubpassDependency2-sType-sType
sType must be VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2
VUID-VkSubpassDependency2-srcStageMask-parameter
srcStageMask must be a valid combination of VkPipelineStageFlagBits values
VUID-VkSubpassDependency2-srcStageMask-requiredbitmask
srcStageMask must not be 0
VUID-VkSubpassDependency2-dstStageMask-parameter
dstStageMask must be a valid combination of VkPipelineStageFlagBits values
VUID-VkSubpassDependency2-dstStageMask-requiredbitmask
dstStageMask must not be 0
VUID-VkSubpassDependency2-srcAccessMask-parameter
srcAccessMask must be a valid combination of VkAccessFlagBits values
VUID-VkSubpassDependency2-dstAccessMask-parameter
dstAccessMask must be a valid combination of VkAccessFlagBits values
VUID-VkSubpassDependency2-dependencyFlags-parameter
dependencyFlags must be a valid combination of VkDependencyFlagBits values

To destroy a render pass, call:

void vkDestroyRenderPass(
    VkDevice                                    device,
    VkRenderPass                                renderPass,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the render pass.
renderPass is the handle of the render pass to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyRenderPass-renderPass-00873
All submitted commands that refer to renderPass must have completed execution
VUID-vkDestroyRenderPass-renderPass-00874
If VkAllocationCallbacks were provided when renderPass was created, a compatible set of callbacks must be provided here
VUID-vkDestroyRenderPass-renderPass-00875
If no VkAllocationCallbacks were provided when renderPass was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyRenderPass-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyRenderPass-renderPass-parameter
If renderPass is not VK_NULL_HANDLE, renderPass must be a valid VkRenderPass handle
VUID-vkDestroyRenderPass-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyRenderPass-renderPass-parent
If renderPass is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to renderPass must be externally synchronized

7.2. Render Pass Compatibility

Framebuffers and graphics pipelines are created based on a specific render pass object. They must only be used with that render pass object, or one compatible with it.

Two attachment references are compatible if they have matching format and sample count, or are both VK_ATTACHMENT_UNUSED or the pointer that would contain the reference is NULL.

Two arrays of attachment references are compatible if all corresponding pairs of attachments are compatible. If the arrays are of different lengths, attachment references not present in the smaller array are treated as VK_ATTACHMENT_UNUSED.

Two render passes are compatible if their corresponding color, input, resolve, and depth/stencil attachment references are compatible and if they are otherwise identical except for:

Initial and final image layout in attachment descriptions
Load and store operations in attachment descriptions
Image layout in attachment references

As an additional special case, if two render passes have a single subpass, the resolve attachment reference and depth/stencil resolve mode compatibility requirements are ignored.

A framebuffer is compatible with a render pass if it was created using the same render pass or a compatible render pass.

7.3. Framebuffers

Render passes operate in conjunction with framebuffers. Framebuffers represent a collection of specific memory attachments that a render pass instance uses.

Framebuffers are represented by VkFramebuffer handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)

To create a framebuffer, call:

VkResult vkCreateFramebuffer(
    VkDevice                                    device,
    const VkFramebufferCreateInfo*              pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkFramebuffer*                              pFramebuffer);

device is the logical device that creates the framebuffer.
pCreateInfo is a pointer to a VkFramebufferCreateInfo structure describing additional information about framebuffer creation.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pFramebuffer is a pointer to a VkFramebuffer handle in which the resulting framebuffer object is returned.

Valid Usage

VUID-vkCreateFramebuffer-pCreateInfo-02777
If pCreateInfo->flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, and attachmentCount is not 0, each element of pCreateInfo->pAttachments must have been created on device

Valid Usage (Implicit)

VUID-vkCreateFramebuffer-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateFramebuffer-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkFramebufferCreateInfo structure
VUID-vkCreateFramebuffer-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateFramebuffer-pFramebuffer-parameter
pFramebuffer must be a valid pointer to a VkFramebuffer handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkFramebufferCreateInfo structure is defined as:

typedef struct VkFramebufferCreateInfo {
    VkStructureType             sType;
    const void*                 pNext;
    VkFramebufferCreateFlags    flags;
    VkRenderPass                renderPass;
    uint32_t                    attachmentCount;
    const VkImageView*          pAttachments;
    uint32_t                    width;
    uint32_t                    height;
    uint32_t                    layers;
} VkFramebufferCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkFramebufferCreateFlagBits
renderPass is a render pass defining what render passes the framebuffer will be compatible with. See Render Pass Compatibility for details.
attachmentCount is the number of attachments.
pAttachments is a pointer to an array of VkImageView handles, each of which will be used as the corresponding attachment in a render pass instance. If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, this parameter is ignored.
width, height and layers define the dimensions of the framebuffer. If the render pass uses multiview, then layers must be one and each attachment requires a number of layers that is greater than the maximum bit index set in the view mask in the subpasses in which it is used.

Applications must ensure that all accesses to memory that backs image subresources used as attachments in a given renderpass instance either happen-before the load operations for those attachments, or happen-after the store operations for those attachments.

For depth/stencil attachments, each aspect can be used separately as attachments and non-attachments as long as the non-attachment accesses are also via an image subresource in either the VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL layout or the VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL layout, and the attachment resource uses whichever of those two layouts the image accesses do not. Use of non-attachment aspects in this case is only well defined if the attachment is used in the subpass where the non-attachment access is being made, or the layout of the image subresource is constant throughout the entire render pass instance, including the initialLayout and finalLayout.

Note

These restrictions mean that the render pass has full knowledge of all uses of all of the attachments, so that the implementation is able to make correct decisions about when and how to perform layout transitions, when to overlap execution of subpasses, etc.

It is legal for a subpass to use no color or depth/stencil attachments, and rather use shader side effects such as image stores and atomics to produce an output. In this case, the subpass continues to use the width, height, and layers of the framebuffer to define the dimensions of the rendering area, and the rasterizationSamples from each pipeline’s VkPipelineMultisampleStateCreateInfo to define the number of samples used in rasterization; however, if VkPhysicalDeviceFeatures::variableMultisampleRate is VK_FALSE, then all pipelines to be bound with a given zero-attachment subpass must have the same value for VkPipelineMultisampleStateCreateInfo::rasterizationSamples.

Valid Usage

VUID-VkFramebufferCreateInfo-attachmentCount-00876
attachmentCount must be equal to the attachment count specified in renderPass
VUID-VkFramebufferCreateInfo-flags-02778
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, and attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkImageView handles
VUID-VkFramebufferCreateInfo-pAttachments-00877
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a color attachment or resolve attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
VUID-VkFramebufferCreateInfo-pAttachments-02633
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a depth/stencil attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
VUID-VkFramebufferCreateInfo-pAttachments-02634
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a depth/stencil resolve attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
VUID-VkFramebufferCreateInfo-pAttachments-00879
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as an input attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
VUID-VkFramebufferCreateInfo-pAttachments-02552
Each element of pAttachments that is used as a fragment density map attachment by renderPass must not have been created with a flags value including VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT.
VUID-VkFramebufferCreateInfo-renderPass-02553
If renderPass has a fragment density map attachment and non-subsample image feature is not enabled, each element of pAttachments must have been created with a flags value including VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT unless that element is the fragment density map attachment.
VUID-VkFramebufferCreateInfo-pAttachments-00880
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must have been created with a VkFormat value that matches the VkFormat specified by the corresponding VkAttachmentDescription in renderPass
VUID-VkFramebufferCreateInfo-pAttachments-00881
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must have been created with a samples value that matches the samples value specified by the corresponding VkAttachmentDescription in renderPass
VUID-VkFramebufferCreateInfo-pAttachments-02554
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must have dimensions at least as large as the corresponding framebuffer dimension except for any element that is referenced by fragmentDensityMapAttachment
VUID-VkFramebufferCreateInfo-renderPass-02745
If renderPass was specified with non-zero view masks, each element of pAttachments that is not referenced by fragmentDensityMapAttachment must have a layerCount greater than the index of the most significant bit set in any of those view masks
VUID-VkFramebufferCreateInfo-renderPass-02746
If renderPass was specified with non-zero view masks, each element of pAttachments that is referenced by fragmentDensityMapAttachment must have a layerCount equal to 1 or greater than the index of the most significant bit set in any of those view masks
VUID-VkFramebufferCreateInfo-renderPass-02747
If renderPass was not specified with non-zero view masks, each element of pAttachments that is referenced by fragmentDensityMapAttachment must have a layerCount equal to 1
VUID-VkFramebufferCreateInfo-pAttachments-02555
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, an element of pAttachments that is referenced by fragmentDensityMapAttachment must have a width at least as large as \(\lceil{\frac{width}{maxFragmentDensityTexelSize_{width}}}\rceil\)
VUID-VkFramebufferCreateInfo-pAttachments-02556
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, an element of pAttachments that is referenced by fragmentDensityMapAttachment must have a height at least as large as \(\lceil{\frac{height}{maxFragmentDensityTexelSize_{height}}}\rceil\)
VUID-VkFramebufferCreateInfo-pAttachments-00883
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must only specify a single mip level
VUID-VkFramebufferCreateInfo-pAttachments-00884
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must have been created with the identity swizzle
VUID-VkFramebufferCreateInfo-width-00885
width must be greater than 0.
VUID-VkFramebufferCreateInfo-width-00886
width must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferWidth
VUID-VkFramebufferCreateInfo-height-00887
height must be greater than 0.
VUID-VkFramebufferCreateInfo-height-00888
height must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferHeight
VUID-VkFramebufferCreateInfo-layers-00889
layers must be greater than 0.
VUID-VkFramebufferCreateInfo-layers-00890
layers must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferLayers
VUID-VkFramebufferCreateInfo-renderPass-02531
If renderPass was specified with non-zero view masks, layers must be 1
VUID-VkFramebufferCreateInfo-pAttachments-00891
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is a 2D or 2D array image view taken from a 3D image must not be a depth/stencil format
VUID-VkFramebufferCreateInfo-flags-03188
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, and attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkImageView handles
VUID-VkFramebufferCreateInfo-flags-03189
If the imageless framebuffer feature is not enabled, flags must not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT
VUID-VkFramebufferCreateInfo-flags-03190
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the pNext chain must include a VkFramebufferAttachmentsCreateInfo structure
VUID-VkFramebufferCreateInfo-flags-03191
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the attachmentImageInfoCount member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain must be equal to either zero or attachmentCount
VUID-VkFramebufferCreateInfo-flags-03194
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the width member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain must be greater than or equal to width, except for any element that is referenced by VkRenderPassFragmentDensityMapCreateInfoEXT::fragmentDensityMapAttachment in renderPass
VUID-VkFramebufferCreateInfo-flags-03195
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the height member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain must be greater than or equal to height, except for any element that is referenced by VkRenderPassFragmentDensityMapCreateInfoEXT::fragmentDensityMapAttachment in renderPass
VUID-VkFramebufferCreateInfo-flags-03196
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the width member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain that is referenced by VkRenderPassFragmentDensityMapCreateInfoEXT::fragmentDensityMapAttachment in renderPass must be greater than or equal to \(\lceil{\frac{width}{maxFragmentDensityTexelSize_{width}}}\rceil\)
VUID-VkFramebufferCreateInfo-flags-03197
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the height member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain that is referenced by VkRenderPassFragmentDensityMapCreateInfoEXT::fragmentDensityMapAttachment in renderPass must be greater than or equal to \(\lceil{\frac{height}{maxFragmentDensityTexelSize_{height}}}\rceil\)
VUID-VkFramebufferCreateInfo-renderPass-03198
If multiview is enabled for renderPass, and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the layerCount member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain must be greater than the maximum bit index set in the view mask in the subpasses in which it is used in renderPass
VUID-VkFramebufferCreateInfo-renderPass-03199
If multiview is not enabled for renderPass, and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the layerCount member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain must be greater than or equal to layers
VUID-VkFramebufferCreateInfo-flags-03201
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the usage member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain that refers to an attachment used as a color attachment or resolve attachment by renderPass must include VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
VUID-VkFramebufferCreateInfo-flags-03202
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the usage member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain that refers to an attachment used as a depth/stencil attachment by renderPass must include VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
VUID-VkFramebufferCreateInfo-flags-03203
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the usage member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain that refers to an attachment used as a depth/stencil resolve attachment by renderPass must include VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
VUID-VkFramebufferCreateInfo-flags-03204
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the usage member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain that refers to an attachment used as an input attachment by renderPass must include VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
VUID-VkFramebufferCreateInfo-flags-03205
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, at least one element of the pViewFormats member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain must be equal to the corresponding value of VkAttachmentDescription::format used to create renderPass

Valid Usage (Implicit)

VUID-VkFramebufferCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
VUID-VkFramebufferCreateInfo-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkFramebufferAttachmentsCreateInfo
VUID-VkFramebufferCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkFramebufferCreateInfo-flags-parameter
flags must be a valid combination of VkFramebufferCreateFlagBits values
VUID-VkFramebufferCreateInfo-renderPass-parameter
renderPass must be a valid VkRenderPass handle
VUID-VkFramebufferCreateInfo-commonparent
Both of renderPass, and the elements of pAttachments that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

The VkFramebufferAttachmentsCreateInfo structure is defined as:

typedef struct VkFramebufferAttachmentsCreateInfo {
    VkStructureType                            sType;
    const void*                                pNext;
    uint32_t                                   attachmentImageInfoCount;
    const VkFramebufferAttachmentImageInfo*    pAttachmentImageInfos;
} VkFramebufferAttachmentsCreateInfo;

or the equivalent

typedef VkFramebufferAttachmentsCreateInfo VkFramebufferAttachmentsCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
attachmentImageInfoCount is the number of attachments being described.
pAttachmentImageInfos is a pointer to an array of VkFramebufferAttachmentImageInfo instances, each of which describes a number of parameters of the corresponding attachment in a render pass instance.

Valid Usage (Implicit)

VUID-VkFramebufferAttachmentsCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO
VUID-VkFramebufferAttachmentsCreateInfo-pAttachmentImageInfos-parameter
If attachmentImageInfoCount is not 0, pAttachmentImageInfos must be a valid pointer to an array of attachmentImageInfoCount valid VkFramebufferAttachmentImageInfo structures

The VkFramebufferAttachmentImageInfo structure is defined as:

typedef struct VkFramebufferAttachmentImageInfo {
    VkStructureType       sType;
    const void*           pNext;
    VkImageCreateFlags    flags;
    VkImageUsageFlags     usage;
    uint32_t              width;
    uint32_t              height;
    uint32_t              layerCount;
    uint32_t              viewFormatCount;
    const VkFormat*       pViewFormats;
} VkFramebufferAttachmentImageInfo;

or the equivalent

typedef VkFramebufferAttachmentImageInfo VkFramebufferAttachmentImageInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkImageCreateFlagBits, matching the value of VkImageCreateInfo::flags used to create an image that will be used with this framebuffer.
usage is a bitmask of VkImageUsageFlagBits, matching the value of VkImageCreateInfo::usage used to create an image used with this framebuffer.
width is the width of the image view used for rendering.
height is the height of the image view used for rendering.
viewFormatCount is the number of entries in the pViewFormats array, matching the value of VkImageFormatListCreateInfo::viewFormatCount used to create an image used with this framebuffer.
pViewFormats is an array which lists of all formats which can be used when creating views of the image, matching the value of VkImageFormatListCreateInfo::pViewFormats used to create an image used with this framebuffer.

Images that can be used with the framebuffer when beginning a render pass, as specified by VkRenderPassAttachmentBeginInfo, must be created with parameters that are identical to those specified here.

Valid Usage (Implicit)

VUID-VkFramebufferAttachmentImageInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO
VUID-VkFramebufferAttachmentImageInfo-pNext-pNext
pNext must be NULL
VUID-VkFramebufferAttachmentImageInfo-flags-parameter
flags must be a valid combination of VkImageCreateFlagBits values
VUID-VkFramebufferAttachmentImageInfo-usage-parameter
usage must be a valid combination of VkImageUsageFlagBits values
VUID-VkFramebufferAttachmentImageInfo-usage-requiredbitmask
usage must not be 0
VUID-VkFramebufferAttachmentImageInfo-pViewFormats-parameter
If viewFormatCount is not 0, pViewFormats must be a valid pointer to an array of viewFormatCount valid VkFormat values

Bits which can be set in VkFramebufferCreateInfo::flags to specify options for framebuffers are:

typedef enum VkFramebufferCreateFlagBits {
    VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 0x00000001,
    VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT,
    VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkFramebufferCreateFlagBits;

VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT specifies that image views are not specified, and only attachment compatibility information will be provided via a VkFramebufferAttachmentImageInfo structure.

typedef VkFlags VkFramebufferCreateFlags;

VkFramebufferCreateFlags is a bitmask type for setting a mask of zero or more VkFramebufferCreateFlagBits.

To destroy a framebuffer, call:

void vkDestroyFramebuffer(
    VkDevice                                    device,
    VkFramebuffer                               framebuffer,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the framebuffer.
framebuffer is the handle of the framebuffer to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyFramebuffer-framebuffer-00892
All submitted commands that refer to framebuffer must have completed execution
VUID-vkDestroyFramebuffer-framebuffer-00893
If VkAllocationCallbacks were provided when framebuffer was created, a compatible set of callbacks must be provided here
VUID-vkDestroyFramebuffer-framebuffer-00894
If no VkAllocationCallbacks were provided when framebuffer was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyFramebuffer-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyFramebuffer-framebuffer-parameter
If framebuffer is not VK_NULL_HANDLE, framebuffer must be a valid VkFramebuffer handle
VUID-vkDestroyFramebuffer-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyFramebuffer-framebuffer-parent
If framebuffer is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to framebuffer must be externally synchronized

7.4. Render Pass Commands

An application records the commands for a render pass instance one subpass at a time, by beginning a render pass instance, iterating over the subpasses to record commands for that subpass, and then ending the render pass instance.

To begin a render pass instance, call:

void vkCmdBeginRenderPass(
    VkCommandBuffer                             commandBuffer,
    const VkRenderPassBeginInfo*                pRenderPassBegin,
    VkSubpassContents                           contents);

commandBuffer is the command buffer in which to record the command.
pRenderPassBegin is a pointer to a VkRenderPassBeginInfo structure specifying the render pass to begin an instance of, and the framebuffer the instance uses.
contents is a VkSubpassContents value specifying how the commands in the first subpass will be provided.

After beginning a render pass instance, the command buffer is ready to record the commands for the first subpass of that render pass.

Valid Usage

VUID-vkCmdBeginRenderPass-initialLayout-00895
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
VUID-vkCmdBeginRenderPass-initialLayout-01758
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
VUID-vkCmdBeginRenderPass-initialLayout-02842
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
VUID-vkCmdBeginRenderPass-stencilInitialLayout-02843
If any of the stencilInitialLayout or stencilFinalLayout member of the VkAttachmentDescriptionStencilLayout structures or the stencilLayout member of the VkAttachmentReferenceStencilLayout structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
VUID-vkCmdBeginRenderPass-initialLayout-00897
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
VUID-vkCmdBeginRenderPass-initialLayout-00898
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_TRANSFER_SRC_BIT
VUID-vkCmdBeginRenderPass-initialLayout-00899
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_TRANSFER_DST_BIT
VUID-vkCmdBeginRenderPass-initialLayout-00900
If any of the initialLayout members of the VkAttachmentDescription structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is not VK_IMAGE_LAYOUT_UNDEFINED, then each such initialLayout must be equal to the current layout of the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin
VUID-vkCmdBeginRenderPass-srcStageMask-00901
The srcStageMask and dstStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from
VUID-vkCmdBeginRenderPass-framebuffer-02532
For any attachment in framebuffer that is used by renderPass and is bound to memory locations that are also bound to another attachment used by renderPass, and if at least one of those uses causes either attachment to be written to, both attachments must have had the VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT set

Valid Usage (Implicit)

VUID-vkCmdBeginRenderPass-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdBeginRenderPass-pRenderPassBegin-parameter
pRenderPassBegin must be a valid pointer to a valid VkRenderPassBeginInfo structure
VUID-vkCmdBeginRenderPass-contents-parameter
contents must be a valid VkSubpassContents value
VUID-vkCmdBeginRenderPass-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdBeginRenderPass-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdBeginRenderPass-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdBeginRenderPass-bufferlevel
commandBuffer must be a primary VkCommandBuffer

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary

Outside

Graphics

Alternatively to begin a render pass, call:

void vkCmdBeginRenderPass2(
    VkCommandBuffer                             commandBuffer,
    const VkRenderPassBeginInfo*                pRenderPassBegin,
    const VkSubpassBeginInfo*                   pSubpassBeginInfo);

or the equivalent command

void vkCmdBeginRenderPass2KHR(
    VkCommandBuffer                             commandBuffer,
    const VkRenderPassBeginInfo*                pRenderPassBegin,
    const VkSubpassBeginInfo*                   pSubpassBeginInfo);

commandBuffer is the command buffer in which to record the command.
pRenderPassBegin is a pointer to a VkRenderPassBeginInfo structure specifying the render pass to begin an instance of, and the framebuffer the instance uses.
pSubpassBeginInfo is a pointer to a VkSubpassBeginInfo structure containing information about the subpass which is about to begin rendering.

After beginning a render pass instance, the command buffer is ready to record the commands for the first subpass of that render pass.

Valid Usage

VUID-vkCmdBeginRenderPass2-framebuffer-02779
Both the framebuffer and renderPass members of pRenderPassBegin must have been created on the same VkDevice that commandBuffer was allocated on
VUID-vkCmdBeginRenderPass2-initialLayout-03094
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
VUID-vkCmdBeginRenderPass2-initialLayout-03096
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
VUID-vkCmdBeginRenderPass2-initialLayout-02844
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
VUID-vkCmdBeginRenderPass2-stencilInitialLayout-02845
If any of the stencilInitialLayout or stencilFinalLayout member of the VkAttachmentDescriptionStencilLayout structures or the stencilLayout member of the VkAttachmentReferenceStencilLayout structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
VUID-vkCmdBeginRenderPass2-initialLayout-03097
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
VUID-vkCmdBeginRenderPass2-initialLayout-03098
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_TRANSFER_SRC_BIT
VUID-vkCmdBeginRenderPass2-initialLayout-03099
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_TRANSFER_DST_BIT
VUID-vkCmdBeginRenderPass2-initialLayout-03100
If any of the initialLayout members of the VkAttachmentDescription structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is not VK_IMAGE_LAYOUT_UNDEFINED, then each such initialLayout must be equal to the current layout of the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin
VUID-vkCmdBeginRenderPass2-srcStageMask-03101
The srcStageMask and dstStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from
VUID-vkCmdBeginRenderPass2-framebuffer-02533
For any attachment in framebuffer that is used by renderPass and is bound to memory locations that are also bound to another attachment used by renderPass, and if at least one of those uses causes either attachment to be written to, both attachments must have had the VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT set

Valid Usage (Implicit)

VUID-vkCmdBeginRenderPass2-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdBeginRenderPass2-pRenderPassBegin-parameter
pRenderPassBegin must be a valid pointer to a valid VkRenderPassBeginInfo structure
VUID-vkCmdBeginRenderPass2-pSubpassBeginInfo-parameter
pSubpassBeginInfo must be a valid pointer to a valid VkSubpassBeginInfo structure
VUID-vkCmdBeginRenderPass2-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdBeginRenderPass2-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdBeginRenderPass2-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdBeginRenderPass2-bufferlevel
commandBuffer must be a primary VkCommandBuffer

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary

Outside

Graphics

The VkRenderPassBeginInfo structure is defined as:

typedef struct VkRenderPassBeginInfo {
    VkStructureType        sType;
    const void*            pNext;
    VkRenderPass           renderPass;
    VkFramebuffer          framebuffer;
    VkRect2D               renderArea;
    uint32_t               clearValueCount;
    const VkClearValue*    pClearValues;
} VkRenderPassBeginInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
renderPass is the render pass to begin an instance of.
framebuffer is the framebuffer containing the attachments that are used with the render pass.
renderArea is the render area that is affected by the render pass instance, and is described in more detail below.
clearValueCount is the number of elements in pClearValues.
pClearValues is a pointer to an array of clearValueCount VkClearValue structures that contains clear values for each attachment, if the attachment uses a loadOp value of VK_ATTACHMENT_LOAD_OP_CLEAR or if the attachment has a depth/stencil format and uses a stencilLoadOp value of VK_ATTACHMENT_LOAD_OP_CLEAR. The array is indexed by attachment number. Only elements corresponding to cleared attachments are used. Other elements of pClearValues are ignored.

renderArea is the render area that is affected by the render pass instance. The effects of attachment load, store and multisample resolve operations are restricted to the pixels whose x and y coordinates fall within the render area on all attachments. The render area extends to all layers of framebuffer. The application must ensure (using scissor if necessary) that all rendering is contained within the render area.

When multiview is enabled, the resolve operation at the end of a subpass applies to all views in the view mask.

Note

There may be a performance cost for using a render area smaller than the framebuffer, unless it matches the render area granularity for the render pass.

Valid Usage

VUID-VkRenderPassBeginInfo-clearValueCount-00902
clearValueCount must be greater than the largest attachment index in renderPass that specifies a loadOp (or stencilLoadOp, if the attachment has a depth/stencil format) of VK_ATTACHMENT_LOAD_OP_CLEAR
VUID-VkRenderPassBeginInfo-renderPass-00904
renderPass must be compatible with the renderPass member of the VkFramebufferCreateInfo structure specified when creating framebuffer
VUID-VkRenderPassBeginInfo-pNext-02850
If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, renderArea.offset.x must be greater than or equal to 0
VUID-VkRenderPassBeginInfo-pNext-02851
If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, renderArea.offset.y must be greater than or equal to 0
VUID-VkRenderPassBeginInfo-pNext-02852
If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, renderArea.offset.x + renderArea.offset.width must be less than or equal to VkFramebufferCreateInfo::width the framebuffer was created with
VUID-VkRenderPassBeginInfo-pNext-02853
If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, renderArea.offset.y + renderArea.offset.height must be less than or equal to VkFramebufferCreateInfo::height the framebuffer was created with
VUID-VkRenderPassBeginInfo-pNext-02854
If the pNext chain contains VkDeviceGroupRenderPassBeginInfo, the offset.x member of each element of pDeviceRenderAreas must be greater than or equal to 0
VUID-VkRenderPassBeginInfo-pNext-02855
If the pNext chain contains VkDeviceGroupRenderPassBeginInfo, the offset.y member of each element of pDeviceRenderAreas must be greater than or equal to 0
VUID-VkRenderPassBeginInfo-pNext-02856
If the pNext chain contains VkDeviceGroupRenderPassBeginInfo, offset.x + offset.width of each element of pDeviceRenderAreas must be less than or equal to VkFramebufferCreateInfo::width the framebuffer was created with
VUID-VkRenderPassBeginInfo-pNext-02857
If the pNext chain contains VkDeviceGroupRenderPassBeginInfo, offset.y + offset.height of each element of pDeviceRenderAreas must be less than or equal to VkFramebufferCreateInfo::height the framebuffer was created with
VUID-VkRenderPassBeginInfo-framebuffer-03207
If framebuffer was created with a VkFramebufferCreateInfo::flags value that did not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, and the pNext chain includes a VkRenderPassAttachmentBeginInfo structure, its attachmentCount must be zero
VUID-VkRenderPassBeginInfo-framebuffer-03208
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the attachmentCount of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be equal to the value of VkFramebufferAttachmentsCreateInfo::attachmentImageInfoCount used to create framebuffer
VUID-VkRenderPassBeginInfo-framebuffer-02780
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must have been created on the same VkDevice as framebuffer and renderPass
VUID-VkRenderPassBeginInfo-framebuffer-03209
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a value of VkImageCreateInfo::flags equal to the flags member of the corresponding element of VkFramebufferAttachmentsCreateInfoKHR::pAttachments used to create framebuffer
VUID-VkRenderPassBeginInfo-framebuffer-03210
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a value of VkImageCreateInfo::usage equal to the usage member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachments used to create framebuffer
VUID-VkRenderPassBeginInfo-framebuffer-03211
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView with a width equal to the width member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachments used to create framebuffer
VUID-VkRenderPassBeginInfo-framebuffer-03212
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView with a height equal to the height member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachments used to create framebuffer
VUID-VkRenderPassBeginInfo-framebuffer-03213
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a value of VkImageViewCreateInfo::subresourceRange.layerCount equal to the layerCount member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachments used to create framebuffer
VUID-VkRenderPassBeginInfo-framebuffer-03214
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a value of VkImageFormatListCreateInfo::viewFormatCount equal to the viewFormatCount member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachments used to create framebuffer
VUID-VkRenderPassBeginInfo-framebuffer-03215
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a set of elements in VkImageFormatListCreateInfo::pViewFormats equal to the set of elements in the pViewFormats member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachments used to create framebuffer
VUID-VkRenderPassBeginInfo-framebuffer-03216
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a value of VkImageViewCreateInfo::format equal to the corresponding value of VkAttachmentDescription::format in renderPass
VUID-VkRenderPassBeginInfo-framebuffer-03217
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a value of VkImageCreateInfo::samples equal to the corresponding value of VkAttachmentDescription::samples in renderPass

Valid Usage (Implicit)

VUID-VkRenderPassBeginInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO
VUID-VkRenderPassBeginInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupRenderPassBeginInfo, VkRenderPassAttachmentBeginInfo, or VkRenderPassSampleLocationsBeginInfoEXT
VUID-VkRenderPassBeginInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkRenderPassBeginInfo-renderPass-parameter
renderPass must be a valid VkRenderPass handle
VUID-VkRenderPassBeginInfo-framebuffer-parameter
framebuffer must be a valid VkFramebuffer handle
VUID-VkRenderPassBeginInfo-pClearValues-parameter
If clearValueCount is not 0, pClearValues must be a valid pointer to an array of clearValueCount VkClearValue unions
VUID-VkRenderPassBeginInfo-commonparent
Both of framebuffer, and renderPass must have been created, allocated, or retrieved from the same VkDevice

The image layout of the depth aspect of a depth/stencil attachment referring to an image created with VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT is dependent on the last sample locations used to render to the image subresource, thus preserving the contents of such depth/stencil attachments across subpass boundaries requires the application to specify these sample locations whenever a layout transition of the attachment may occur. This information can be provided by adding a VkRenderPassSampleLocationsBeginInfoEXT structure to the pNext chain of VkRenderPassBeginInfo.

The VkRenderPassSampleLocationsBeginInfoEXT structure is defined as:

typedef struct VkRenderPassSampleLocationsBeginInfoEXT {
    VkStructureType                          sType;
    const void*                              pNext;
    uint32_t                                 attachmentInitialSampleLocationsCount;
    const VkAttachmentSampleLocationsEXT*    pAttachmentInitialSampleLocations;
    uint32_t                                 postSubpassSampleLocationsCount;
    const VkSubpassSampleLocationsEXT*       pPostSubpassSampleLocations;
} VkRenderPassSampleLocationsBeginInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
attachmentInitialSampleLocationsCount is the number of elements in the pAttachmentInitialSampleLocations array.
pAttachmentInitialSampleLocations is a pointer to an array of attachmentInitialSampleLocationsCount VkAttachmentSampleLocationsEXT structures specifying the attachment indices and their corresponding sample location state. Each element of pAttachmentInitialSampleLocations can specify the sample location state to use in the automatic layout transition performed to transition a depth/stencil attachment from the initial layout of the attachment to the image layout specified for the attachment in the first subpass using it.
postSubpassSampleLocationsCount is the number of elements in the pPostSubpassSampleLocations array.
pPostSubpassSampleLocations is a pointer to an array of postSubpassSampleLocationsCount VkSubpassSampleLocationsEXT structures specifying the subpass indices and their corresponding sample location state. Each element of pPostSubpassSampleLocations can specify the sample location state to use in the automatic layout transition performed to transition the depth/stencil attachment used by the specified subpass to the image layout specified in a dependent subpass or to the final layout of the attachment in case the specified subpass is the last subpass using that attachment. In addition, if VkPhysicalDeviceSampleLocationsPropertiesEXT::variableSampleLocations is VK_FALSE, each element of pPostSubpassSampleLocations must specify the sample location state that matches the sample locations used by all pipelines that will be bound to a command buffer during the specified subpass. If variableSampleLocations is VK_TRUE, the sample locations used for rasterization do not depend on pPostSubpassSampleLocations.

Valid Usage (Implicit)

VUID-VkRenderPassSampleLocationsBeginInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT
VUID-VkRenderPassSampleLocationsBeginInfoEXT-pAttachmentInitialSampleLocations-parameter
If attachmentInitialSampleLocationsCount is not 0, pAttachmentInitialSampleLocations must be a valid pointer to an array of attachmentInitialSampleLocationsCount valid VkAttachmentSampleLocationsEXT structures
VUID-VkRenderPassSampleLocationsBeginInfoEXT-pPostSubpassSampleLocations-parameter
If postSubpassSampleLocationsCount is not 0, pPostSubpassSampleLocations must be a valid pointer to an array of postSubpassSampleLocationsCount valid VkSubpassSampleLocationsEXT structures

The VkAttachmentSampleLocationsEXT structure is defined as:

typedef struct VkAttachmentSampleLocationsEXT {
    uint32_t                    attachmentIndex;
    VkSampleLocationsInfoEXT    sampleLocationsInfo;
} VkAttachmentSampleLocationsEXT;

attachmentIndex is the index of the attachment for which the sample locations state is provided.
sampleLocationsInfo is the sample locations state to use for the layout transition of the given attachment from the initial layout of the attachment to the image layout specified for the attachment in the first subpass using it.

If the image referenced by the framebuffer attachment at index attachmentIndex was not created with VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT then the values specified in sampleLocationsInfo are ignored.

Valid Usage

VUID-VkAttachmentSampleLocationsEXT-attachmentIndex-01531
attachmentIndex must be less than the attachmentCount specified in VkRenderPassCreateInfo the render pass specified by VkRenderPassBeginInfo::renderPass was created with

Valid Usage (Implicit)

VUID-VkAttachmentSampleLocationsEXT-sampleLocationsInfo-parameter
sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure

The VkSubpassSampleLocationsEXT structure is defined as:

typedef struct VkSubpassSampleLocationsEXT {
    uint32_t                    subpassIndex;
    VkSampleLocationsInfoEXT    sampleLocationsInfo;
} VkSubpassSampleLocationsEXT;

subpassIndex is the index of the subpass for which the sample locations state is provided.
sampleLocationsInfo is the sample locations state to use for the layout transition of the depth/stencil attachment away from the image layout the attachment is used with in the subpass specified in subpassIndex.

If the image referenced by the depth/stencil attachment used in the subpass identified by subpassIndex was not created with VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT or if the subpass does not use a depth/stencil attachment, and VkPhysicalDeviceSampleLocationsPropertiesEXT::variableSampleLocations is VK_TRUE then the values specified in sampleLocationsInfo are ignored.

Valid Usage

VUID-VkSubpassSampleLocationsEXT-subpassIndex-01532
subpassIndex must be less than the subpassCount specified in VkRenderPassCreateInfo the render pass specified by VkRenderPassBeginInfo::renderPass was created with

Valid Usage (Implicit)

VUID-VkSubpassSampleLocationsEXT-sampleLocationsInfo-parameter
sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure

The VkSubpassBeginInfo structure is defined as:

typedef struct VkSubpassBeginInfo {
    VkStructureType      sType;
    const void*          pNext;
    VkSubpassContents    contents;
} VkSubpassBeginInfo;

or the equivalent

typedef VkSubpassBeginInfo VkSubpassBeginInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
contents is a VkSubpassContents value specifying how the commands in the next subpass will be provided.

Valid Usage (Implicit)

VUID-VkSubpassBeginInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO
VUID-VkSubpassBeginInfo-pNext-pNext
pNext must be NULL
VUID-VkSubpassBeginInfo-contents-parameter
contents must be a valid VkSubpassContents value

Possible values of vkCmdBeginRenderPass::contents, specifying how the commands in the first subpass will be provided, are:

typedef enum VkSubpassContents {
    VK_SUBPASS_CONTENTS_INLINE = 0,
    VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
    VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
} VkSubpassContents;

VK_SUBPASS_CONTENTS_INLINE specifies that 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.
VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS specifies that the contents are recorded in secondary command buffers that will be called from the primary command buffer, and vkCmdExecuteCommands is the only valid command on the command buffer until vkCmdNextSubpass or vkCmdEndRenderPass.

If the pNext chain of VkRenderPassBeginInfo includes a VkDeviceGroupRenderPassBeginInfo structure, then that structure includes a device mask and set of render areas for the render pass instance.

The VkDeviceGroupRenderPassBeginInfo structure is defined as:

typedef struct VkDeviceGroupRenderPassBeginInfo {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           deviceMask;
    uint32_t           deviceRenderAreaCount;
    const VkRect2D*    pDeviceRenderAreas;
} VkDeviceGroupRenderPassBeginInfo;

or the equivalent

typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
deviceMask is the device mask for the render pass instance.
deviceRenderAreaCount is the number of elements in the pDeviceRenderAreas array.
pDeviceRenderAreas is a pointer to an array of VkRect2D structures defining the render area for each physical device.

The deviceMask serves several purposes. It is an upper bound on the set of physical devices that can be used during the render pass instance, and the initial device mask when the render pass instance begins. In addition, commands transitioning to the next subpass in the render pass instance and commands ending the render pass instance, and, accordingly render pass attachment load, store, and resolve operations and subpass dependencies corresponding to the render pass instance, are executed on the physical devices included in the device mask provided here.

If deviceRenderAreaCount is not zero, then the elements of pDeviceRenderAreas override the value of VkRenderPassBeginInfo::renderArea, and provide a render area specific to each physical device. These render areas serve the same purpose as VkRenderPassBeginInfo::renderArea, including controlling the region of attachments that are cleared by VK_ATTACHMENT_LOAD_OP_CLEAR and that are resolved into resolve attachments.

If this structure is not present, the render pass instance’s device mask is the value of VkDeviceGroupCommandBufferBeginInfo::deviceMask. If this structure is not present or if deviceRenderAreaCount is zero, VkRenderPassBeginInfo::renderArea is used for all physical devices.

Valid Usage

VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00905
deviceMask must be a valid device mask value
VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00906
deviceMask must not be zero
VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00907
deviceMask must be a subset of the command buffer’s initial device mask
VUID-VkDeviceGroupRenderPassBeginInfo-deviceRenderAreaCount-00908
deviceRenderAreaCount must either be zero or equal to the number of physical devices in the logical device.

Valid Usage (Implicit)

VUID-VkDeviceGroupRenderPassBeginInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO
VUID-VkDeviceGroupRenderPassBeginInfo-pDeviceRenderAreas-parameter
If deviceRenderAreaCount is not 0, pDeviceRenderAreas must be a valid pointer to an array of deviceRenderAreaCount VkRect2D structures

The VkRenderPassAttachmentBeginInfo structure is defined as:

typedef struct VkRenderPassAttachmentBeginInfo {
    VkStructureType       sType;
    const void*           pNext;
    uint32_t              attachmentCount;
    const VkImageView*    pAttachments;
} VkRenderPassAttachmentBeginInfo;

or the equivalent

typedef VkRenderPassAttachmentBeginInfo VkRenderPassAttachmentBeginInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
attachmentCount is the number of attachments.
pAttachments is a pointer to an array of VkImageView handles, each of which will be used as the corresponding attachment in the render pass instance.

Valid Usage

VUID-VkRenderPassAttachmentBeginInfo-pAttachments-03218
Each element of pAttachments must only specify a single mip level
VUID-VkRenderPassAttachmentBeginInfo-pAttachments-03219
Each element of pAttachments must have been created with the identity swizzle

Valid Usage (Implicit)

VUID-VkRenderPassAttachmentBeginInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO
VUID-VkRenderPassAttachmentBeginInfo-pAttachments-parameter
If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkImageView handles

To query the render area granularity, call:

void vkGetRenderAreaGranularity(
    VkDevice                                    device,
    VkRenderPass                                renderPass,
    VkExtent2D*                                 pGranularity);

device is the logical device that owns the render pass.
renderPass is a handle to a render pass.
pGranularity is a pointer to a VkExtent2D structure in which the granularity is returned.

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.

Subpass dependencies are not affected by the render area, and apply to the entire image subresources attached to the framebuffer as specified in the description of automatic layout transitions. Similarly, pipeline barriers are valid even if their effect extends outside the render area.

Valid Usage (Implicit)

VUID-vkGetRenderAreaGranularity-device-parameter
device must be a valid VkDevice handle
VUID-vkGetRenderAreaGranularity-renderPass-parameter
renderPass must be a valid VkRenderPass handle
VUID-vkGetRenderAreaGranularity-pGranularity-parameter
pGranularity must be a valid pointer to a VkExtent2D structure
VUID-vkGetRenderAreaGranularity-renderPass-parent
renderPass must have been created, allocated, or retrieved from device

To transition to the next subpass in the render pass instance after recording the commands for a subpass, call:

void vkCmdNextSubpass(
    VkCommandBuffer                             commandBuffer,
    VkSubpassContents                           contents);

commandBuffer is the command buffer in which to record the command.
contents specifies how the commands in the next subpass will be provided, in the same fashion as the corresponding parameter of vkCmdBeginRenderPass.

The subpass index for a render pass begins at zero when vkCmdBeginRenderPass 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. This applies to resolve operations for both color and depth/stencil attachments. That is, they are considered to execute in the VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT pipeline stage and their writes are synchronized with VK_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.

Valid Usage

VUID-vkCmdNextSubpass-None-00909
The current subpass index must be less than the number of subpasses in the render pass minus one
VUID-vkCmdNextSubpass-None-02349
This command must not be recorded when transform feedback is active

Valid Usage (Implicit)

VUID-vkCmdNextSubpass-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdNextSubpass-contents-parameter
contents must be a valid VkSubpassContents value
VUID-vkCmdNextSubpass-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdNextSubpass-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdNextSubpass-renderpass
This command must only be called inside of a render pass instance
VUID-vkCmdNextSubpass-bufferlevel
commandBuffer must be a primary VkCommandBuffer

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary

Inside

Graphics

To transition to the next subpass in the render pass instance after recording the commands for a subpass, call:

void vkCmdNextSubpass2(
    VkCommandBuffer                             commandBuffer,
    const VkSubpassBeginInfo*                   pSubpassBeginInfo,
    const VkSubpassEndInfo*                     pSubpassEndInfo);

or the equivalent command

void vkCmdNextSubpass2KHR(
    VkCommandBuffer                             commandBuffer,
    const VkSubpassBeginInfo*                   pSubpassBeginInfo,
    const VkSubpassEndInfo*                     pSubpassEndInfo);

commandBuffer is the command buffer in which to record the command.
pSubpassBeginInfo is a pointer to a VkSubpassBeginInfo structure containing information about the subpass which is about to begin rendering.
pSubpassEndInfo is a pointer to a VkSubpassEndInfo structure containing information about how the previous subpass will be ended.

vkCmdNextSubpass2 is semantically identical to vkCmdNextSubpass, except that it is extensible, and that contents is provided as part of an extensible structure instead of as a flat parameter.

Valid Usage

VUID-vkCmdNextSubpass2-None-03102
The current subpass index must be less than the number of subpasses in the render pass minus one
VUID-vkCmdNextSubpass2-None-02350
This command must not be recorded when transform feedback is active

Valid Usage (Implicit)

VUID-vkCmdNextSubpass2-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdNextSubpass2-pSubpassBeginInfo-parameter
pSubpassBeginInfo must be a valid pointer to a valid VkSubpassBeginInfo structure
VUID-vkCmdNextSubpass2-pSubpassEndInfo-parameter
pSubpassEndInfo must be a valid pointer to a valid VkSubpassEndInfo structure
VUID-vkCmdNextSubpass2-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdNextSubpass2-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdNextSubpass2-renderpass
This command must only be called inside of a render pass instance
VUID-vkCmdNextSubpass2-bufferlevel
commandBuffer must be a primary VkCommandBuffer

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary

Inside

Graphics

To record a command to end a render pass instance after recording the commands for the last subpass, call:

void vkCmdEndRenderPass(
    VkCommandBuffer                             commandBuffer);

commandBuffer is the command buffer in which to end the current render pass instance.

Ending a render pass instance performs any multisample resolve operations on the final subpass.

Valid Usage

VUID-vkCmdEndRenderPass-None-00910
The current subpass index must be equal to the number of subpasses in the render pass minus one
VUID-vkCmdEndRenderPass-None-02351
This command must not be recorded when transform feedback is active

Valid Usage (Implicit)

VUID-vkCmdEndRenderPass-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdEndRenderPass-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdEndRenderPass-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdEndRenderPass-renderpass
This command must only be called inside of a render pass instance
VUID-vkCmdEndRenderPass-bufferlevel
commandBuffer must be a primary VkCommandBuffer

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary

Inside

Graphics

To record a command to end a render pass instance after recording the commands for the last subpass, call:

void vkCmdEndRenderPass2(
    VkCommandBuffer                             commandBuffer,
    const VkSubpassEndInfo*                     pSubpassEndInfo);

or the equivalent command

void vkCmdEndRenderPass2KHR(
    VkCommandBuffer                             commandBuffer,
    const VkSubpassEndInfo*                     pSubpassEndInfo);

commandBuffer is the command buffer in which to end the current render pass instance.
pSubpassEndInfo is a pointer to a VkSubpassEndInfo structure containing information about how the previous subpass will be ended.

vkCmdEndRenderPass2 is semantically identical to vkCmdEndRenderPass, except that it is extensible.

Valid Usage

VUID-vkCmdEndRenderPass2-None-03103
The current subpass index must be equal to the number of subpasses in the render pass minus one
VUID-vkCmdEndRenderPass2-None-02352
This command must not be recorded when transform feedback is active

Valid Usage (Implicit)

VUID-vkCmdEndRenderPass2-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdEndRenderPass2-pSubpassEndInfo-parameter
pSubpassEndInfo must be a valid pointer to a valid VkSubpassEndInfo structure
VUID-vkCmdEndRenderPass2-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdEndRenderPass2-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdEndRenderPass2-renderpass
This command must only be called inside of a render pass instance
VUID-vkCmdEndRenderPass2-bufferlevel
commandBuffer must be a primary VkCommandBuffer

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary

Inside

Graphics

The VkSubpassEndInfo structure is defined as:

typedef struct VkSubpassEndInfo {
    VkStructureType    sType;
    const void*        pNext;
} VkSubpassEndInfo;

or the equivalent

typedef VkSubpassEndInfo VkSubpassEndInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.

Valid Usage (Implicit)

VUID-VkSubpassEndInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_SUBPASS_END_INFO
VUID-VkSubpassEndInfo-pNext-pNext
pNext must be NULL

8. Shaders

A shader specifies programmable operations that execute for each vertex, control point, tessellated vertex, primitive, fragment, or workgroup in the corresponding stage(s) of the graphics and compute pipelines.

Graphics pipelines include vertex shader execution as a result of primitive assembly, followed, if enabled, by tessellation control and evaluation shaders operating on patches, geometry shaders, if enabled, operating on primitives, and fragment shaders, if present, operating on fragments generated by Rasterization. In this specification, vertex, tessellation control, tessellation evaluation and geometry shaders are collectively referred to as vertex processing stages and occur in the logical pipeline before rasterization. The fragment shader occurs logically after rasterization.

Only the compute shader stage is included in a compute pipeline. Compute shaders operate on compute invocations in a workgroup.

Shaders can read from input variables, and read from and write to output variables. Input and output variables can be used to transfer data between shader stages, or to allow the shader to interact with values that exist in the execution environment. Similarly, the execution environment provides constants that describe capabilities.

Shader variables are associated with execution environment-provided inputs and outputs using built-in decorations in the shader. The available decorations for each stage are documented in the following subsections.

8.1. Shader Modules

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, as described by the Vulkan Environment for SPIR-V appendix.

Shader modules are represented by VkShaderModule handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)

To create a shader module, call:

VkResult vkCreateShaderModule(
    VkDevice                                    device,
    const VkShaderModuleCreateInfo*             pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkShaderModule*                             pShaderModule);

device is the logical device that creates the shader module.
pCreateInfo is a pointer to a VkShaderModuleCreateInfo structure.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pShaderModule is a pointer to a VkShaderModule handle in which the resulting shader module object is returned.

Once a shader module has been created, any entry points it contains can be used in pipeline shader stages as described in Compute Pipelines and Graphics Pipelines.

If the shader stage fails to compile VK_ERROR_INVALID_SHADER_NV will be generated and the compile log will be reported back to the application by [VK_EXT_debug_report] if enabled.

Valid Usage (Implicit)

VUID-vkCreateShaderModule-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateShaderModule-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkShaderModuleCreateInfo structure
VUID-vkCreateShaderModule-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateShaderModule-pShaderModule-parameter
pShaderModule must be a valid pointer to a VkShaderModule handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INVALID_SHADER_NV

The VkShaderModuleCreateInfo structure is defined as:

typedef struct VkShaderModuleCreateInfo {
    VkStructureType              sType;
    const void*                  pNext;
    VkShaderModuleCreateFlags    flags;
    size_t                       codeSize;
    const uint32_t*              pCode;
} VkShaderModuleCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
codeSize is the size, in bytes, of the code pointed to by pCode.
pCode is a pointer to code that is used to create the shader module. The type and format of the code is determined from the content of the memory addressed by pCode.

Valid Usage

VUID-VkShaderModuleCreateInfo-codeSize-01085
codeSize must be greater than 0
VUID-VkShaderModuleCreateInfo-pCode-01376
If pCode is a pointer to SPIR-V code, codeSize must be a multiple of 4
VUID-VkShaderModuleCreateInfo-pCode-01377
pCode must point to either valid SPIR-V code, formatted and packed as described by the Khronos SPIR-V Specification or valid GLSL code which must be written to the GL_KHR_vulkan_glsl extension specification
VUID-VkShaderModuleCreateInfo-pCode-01378
If pCode is a pointer to SPIR-V code, that code must adhere to the validation rules described by the Validation Rules within a Module section of the SPIR-V Environment appendix
VUID-VkShaderModuleCreateInfo-pCode-01379
If pCode is a pointer to GLSL code, it must be valid GLSL code written to the GL_KHR_vulkan_glsl GLSL extension specification
VUID-VkShaderModuleCreateInfo-pCode-01089
pCode must declare the Shader capability for SPIR-V code
VUID-VkShaderModuleCreateInfo-pCode-01090
pCode must not declare any capability that is not supported by the API, as described by the Capabilities section of the SPIR-V Environment appendix
VUID-VkShaderModuleCreateInfo-pCode-01091
If pCode declares any of the capabilities listed as optional in the SPIR-V Environment appendix, the corresponding feature(s) must be enabled.

Valid Usage (Implicit)

VUID-VkShaderModuleCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO
VUID-VkShaderModuleCreateInfo-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkShaderModuleValidationCacheCreateInfoEXT
VUID-VkShaderModuleCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkShaderModuleCreateInfo-flags-zerobitmask
flags must be 0
VUID-VkShaderModuleCreateInfo-pCode-parameter
pCode must be a valid pointer to an array of \(\textrm{codeSize} \over 4\) uint32_t values

typedef VkFlags VkShaderModuleCreateFlags;

VkShaderModuleCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

To use a VkValidationCacheEXT to cache shader validation results, add a VkShaderModuleValidationCacheCreateInfoEXT structure to the pNext chain of the VkShaderModuleCreateInfo structure, specifying the cache object to use.

The VkShaderModuleValidationCacheCreateInfoEXT struct is defined as:

typedef struct VkShaderModuleValidationCacheCreateInfoEXT {
    VkStructureType         sType;
    const void*             pNext;
    VkValidationCacheEXT    validationCache;
} VkShaderModuleValidationCacheCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
validationCache is the validation cache object from which the results of prior validation attempts will be written, and to which new validation results for this VkShaderModule will be written (if not already present).

Valid Usage (Implicit)

VUID-VkShaderModuleValidationCacheCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT
VUID-VkShaderModuleValidationCacheCreateInfoEXT-validationCache-parameter
validationCache must be a valid VkValidationCacheEXT handle

To destroy a shader module, call:

void vkDestroyShaderModule(
    VkDevice                                    device,
    VkShaderModule                              shaderModule,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the shader module.
shaderModule is the handle of the shader module to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

A shader module can be destroyed while pipelines created using its shaders are still in use.

Valid Usage

VUID-vkDestroyShaderModule-shaderModule-01092
If VkAllocationCallbacks were provided when shaderModule was created, a compatible set of callbacks must be provided here
VUID-vkDestroyShaderModule-shaderModule-01093
If no VkAllocationCallbacks were provided when shaderModule was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyShaderModule-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyShaderModule-shaderModule-parameter
If shaderModule is not VK_NULL_HANDLE, shaderModule must be a valid VkShaderModule handle
VUID-vkDestroyShaderModule-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyShaderModule-shaderModule-parent
If shaderModule is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to shaderModule must be externally synchronized

8.2. Shader Execution

At each stage of the pipeline, multiple invocations of a shader may execute simultaneously. Further, invocations of a single shader produced as the result of different commands may execute simultaneously. The relative execution order of invocations of the same shader type is undefined. Shader invocations may complete in a different order than that in which the primitives they originated from were drawn or dispatched by the application. However, fragment shader outputs are written to attachments in rasterization order.

The relative execution order of invocations of different shader types is largely undefined. However, when invoking a shader whose inputs are generated from a previous pipeline stage, the shader invocations from the previous stage are guaranteed to have executed far enough to generate input values for all required inputs.

8.3. Shader Memory Access Ordering

The order in which image or buffer memory is read or written by shaders is largely undefined. For some shader types (vertex, tessellation evaluation, and in some cases, fragment), even the number of shader invocations that may perform loads and stores is undefined.

In particular, the following rules apply:

Vertex and tessellation evaluation shaders will be invoked at least once for each unique vertex, as defined in those sections.
Fragment shaders will be invoked zero or more times, as defined in that section.
The relative execution order of invocations of the same shader type is undefined. A store issued by a shader when working on primitive B might complete prior to a store for primitive A, even if primitive A is specified prior to primitive B. This applies even to fragment shaders; while fragment shader outputs are always written to the framebuffer in rasterization order, stores executed by fragment shader invocations are not.
The relative execution order of invocations of different shader types is largely undefined.

Note

The above limitations on shader invocation order make some forms of synchronization between shader invocations within a single set of primitives unimplementable. For example, having one invocation poll memory written by another invocation assumes that the other invocation has been launched and will complete its writes in finite time.

The Memory Model appendix defines the terminology and rules for how to correctly communicate between shader invocations, such as when a write is Visible-To a read, and what constitutes a Data Race.

Applications must not cause a data race.

8.4. Shader Inputs and Outputs

Data is passed into and out of shaders using variables with input or output storage class, respectively. User-defined inputs and outputs are connected between stages by matching their Location decorations. Additionally, data can be provided by or communicated to special functions provided by the execution environment using BuiltIn decorations.

In many cases, the same BuiltIn decoration can be used in multiple shader stages with similar meaning. The specific behavior of variables decorated as BuiltIn is documented in the following sections.

8.5. Task Shaders

Task shaders operate in conjunction with the mesh shaders to produce a collection of primitives that will be processed by subsequent stages of the graphics pipeline. Its primary purpose is to create a variable amount of subsequent mesh shader invocations.

Task shaders are invoked via the execution of the programmable mesh shading pipeline.

The task shader has no fixed-function inputs other than variables identifying the specific workgroup and invocation. The only fixed output of the task shader is a task count, identifying the number of mesh shader workgroups to create. The task shader can write additional outputs to task memory, which can be read by all of the mesh shader workgroups it created.

8.5.1. Task Shader Execution

Task workloads are formed from groups of work items called workgroups and processed by the task shader in the current graphics pipeline. A workgroup is a collection of shader invocations that execute the same shader, potentially in parallel. Task shaders execute in global workgroups which are divided into a number of local workgroups with a size that can be set by assigning a value to the LocalSize execution mode or via an object decorated by the WorkgroupSize decoration. An invocation within a local workgroup can share data with other members of the local workgroup through shared variables and issue memory and control flow barriers to synchronize with other members of the local workgroup.

8.6. Mesh Shaders

Mesh shaders operate in workgroups to produce a collection of primitives that will be processed by subsequent stages of the graphics pipeline. Each workgroup emits zero or more output primitives and the group of vertices and their associated data required for each output primitive.

Mesh shaders are invoked via the execution of the programmable mesh shading pipeline.

The only inputs available to the mesh shader are variables identifying the specific workgroup and invocation and, if applicable, any outputs written to task memory by the task shader that spawned the mesh shader’s workgroup. The mesh shader can operate without a task shader as well.

The invocations of the mesh shader workgroup write an output mesh, comprising a set of primitives with per-primitive attributes, a set of vertices with per-vertex attributes, and an array of indices identifying the mesh vertices that belong to each primitive. The primitives of this mesh are then processed by subsequent graphics pipeline stages, where the outputs of the mesh shader form an interface with the fragment shader.

8.6.1. Mesh Shader Execution

Mesh workloads are formed from groups of work items called workgroups and processed by the mesh shader in the current graphics pipeline. A workgroup is a collection of shader invocations that execute the same shader, potentially in parallel. Mesh shaders execute in global workgroups which are divided into a number of local workgroups with a size that can be set by assigning a value to the LocalSize execution mode or via an object decorated by the WorkgroupSize decoration. An invocation within a local workgroup can share data with other members of the local workgroup through shared variables and issue memory and control flow barriers to synchronize with other members of the local workgroup.

The global workgroups may be generated explcitly via the API, or implicitly through the task shader’s work creation mechanism.

8.7. Vertex Shaders

Each vertex shader invocation operates on one vertex and its associated vertex attribute data, and outputs one vertex and associated data. Graphics pipelines using primitive shading must include a vertex shader, and the vertex shader stage is always the first shader stage in the graphics pipeline.

8.7.1. Vertex Shader Execution

A vertex shader must be executed at least once for each vertex specified by a draw command. If the subpass includes multiple views in its view mask, the shader may be invoked separately for each view. During execution, the shader is presented with the index of the vertex and instance for which it has been invoked. Input variables declared in the vertex shader are filled by the implementation with the values of vertex attributes associated with the invocation being executed.

If the same vertex is specified multiple times in a draw command (e.g. by including the same index value multiple times in an index buffer) the implementation may reuse the results of vertex shading if it can statically determine that the vertex shader invocations will produce identical results.

Note

It is implementation-dependent when and if results of vertex shading are reused, and thus how many times the vertex shader will be executed. This is true also if the vertex shader contains stores or atomic operations (see vertexPipelineStoresAndAtomics).

8.8. Tessellation Control Shaders

The tessellation control shader is used to read an input patch provided by the application and to produce an output patch. Each tessellation control shader invocation operates on an input patch (after all control points in the patch are processed by a vertex shader) and its associated data, and outputs a single control point of the output patch and its associated data, and can also output additional per-patch data. The input patch is sized according to the patchControlPoints member of VkPipelineTessellationStateCreateInfo, as part of input assembly. The size of the output patch is controlled by the OpExecutionMode OutputVertices specified in the tessellation control or tessellation evaluation shaders, which must be specified in at least one of the shaders. The size of the input and output patches must each be greater than zero and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize.

8.8.1. Tessellation Control Shader Execution

A tessellation control shader is invoked at least once for each output vertex in a patch. If the subpass includes multiple views in its view mask, the shader may be invoked separately for each view.

Inputs to the tessellation control shader are generated by the vertex shader. Each invocation of the tessellation control shader can read the attributes of any incoming vertices and their associated data. The invocations corresponding to a given patch execute logically in parallel, with undefined relative execution order. However, the OpControlBarrier instruction can be used to provide limited control of the execution order by synchronizing invocations within a patch, effectively dividing tessellation control shader execution into a set of phases. Tessellation control shaders will read undefined values if one invocation reads a per-vertex or per-patch attribute written by another invocation at any point during the same phase, or if two invocations attempt to write different values to the same per-patch output in a single phase.

8.9. Tessellation Evaluation Shaders

The Tessellation Evaluation Shader operates on an input patch of control points and their associated data, and a single input barycentric coordinate indicating the invocation’s relative position within the subdivided patch, and outputs a single vertex and its associated data.

8.9.1. Tessellation Evaluation Shader Execution

A tessellation evaluation shader is invoked at least once for each unique vertex generated by the tessellator. If the subpass includes multiple views in its view mask, the shader may be invoked separately for each view.

8.10. Geometry Shaders

The geometry shader operates on a group of vertices and their associated data assembled from a single input primitive, and emits zero or more output primitives and the group of vertices and their associated data required for each output primitive.

8.10.1. Geometry Shader Execution

A geometry shader is invoked at least once for each primitive produced by the tessellation stages, or at least once for each primitive generated by primitive assembly when tessellation is not in use. A shader can request that the geometry shader runs multiple instances. A geometry shader is invoked at least once for each instance. If the subpass includes multiple views in its view mask, the shader may be invoked separately for each view.

8.11. Fragment Shaders

Fragment shaders are invoked as the result of rasterization in a graphics pipeline. Each fragment shader invocation operates on a single fragment and its associated data. With few exceptions, fragment shaders do not have access to any data associated with other fragments and are considered to execute in isolation of fragment shader invocations associated with other fragments.

8.11.1. Fragment Shader Execution

For each fragment generated by rasterization, a fragment shader may be invoked. A fragment shader must not be invoked if the Early Per-Fragment Tests cause it to have no coverage. If the subpass includes multiple views in its view mask, the shader may be invoked separately for each view.

Furthermore, if it is determined that a fragment generated as the result of rasterizing a first primitive will have its outputs entirely overwritten by a fragment generated as the result of rasterizing a second primitive in the same subpass, and the fragment shader used for the fragment has no other side effects, then the fragment shader may not be executed for the fragment from the first primitive.

Relative ordering of execution of different fragment shader invocations is not defined.

For each fragment generated by a primitive, the number of times the fragment shader is invoked is implementation-dependent, but must obey the following constraints:

Each covered sample is included in a single fragment shader invocation.
When sample shading is not enabled, there is at least one fragment shader invocation.
When sample shading is enabled, the minimum number of fragment shader invocations is as defined in Shading Rate Image and Sample Shading.

When there is more than one fragment shader invocation per fragment, the association of samples to invocations is implementation-dependent.

In addition to the conditions outlined above for the invocation of a fragment shader, a fragment shader invocation may be produced as a helper invocation. A helper invocation is a fragment shader invocation that is created solely for the purposes of evaluating derivatives for use in non-helper fragment shader invocations. Stores and atomics performed by helper invocations must not have any effect on memory, and values returned by atomic instructions in helper invocations are undefined.

If the render pass has a fragment density map attachment, more than one fragment shader invocation may be invoked for each covered sample. Stores and atomics performed by these additional invocations have the normal effect. Such additional invocations are only produced if VkPhysicalDeviceFragmentDensityMapPropertiesEXT::fragmentDensityInvocations is VK_TRUE.

Note

Implementations may generate these additional fragment shader invocations in order to make transitions between fragment areas with different fragment densities more smooth.

8.11.2. Early Fragment Tests

An explicit control is provided to allow fragment shaders to enable early fragment tests. If the fragment shader specifies the EarlyFragmentTests OpExecutionMode, the per-fragment tests described in Early Fragment Test Mode are performed prior to fragment shader execution. Otherwise, they are performed after fragment shader execution.

If the fragment shader additionally specifies the PostDepthCoverage OpExecutionMode, the value of a variable decorated with the SampleMask built-in reflects the coverage after the early fragment tests. Otherwise, it reflects the coverage before the early fragment tests.

8.11.3. Fragment Shader Interlock

In normal operation, it is possible for more than one fragment shader invocation to be executed simultaneously for the same pixel if there are overlapping primitives. If the fragmentShaderSampleInterlock, fragmentShaderPixelInterlock, or fragmentShaderShadingRateInterlock features are enabled, it is possible to define a critical section within the fragment shader that is guaranteed to not run simultaneously with another fragment shader invocation for the same sample(s) or pixel(s). It is also possible to control the relative ordering of execution of these critical sections across different fragment shader invovations.

If the FragmentShaderSampleInterlockEXT, FragmentShaderPixelInterlockEXT, or FragmentShaderShadingRateInterlockEXT capabilities are declared in the fragment shader, the OpBeginInvocationInterlockEXT and OpEndInvocationInterlockEXT instructions must be used to delimit a critical section of fragment shader code.

To ensure each invocation of the critical section is executed in primitive order, declare one of the PixelInterlockOrderedEXT, SampleInterlockOrderedEXT, or ShadingRateInterlockOrderedEXT execution modes. If the order of execution of each invocation of the critical section does not matter, declare one of the PixelInterlockUnorderedEXT, SampleInterlockUnorderedEXT, or ShadingRateInterlockUnorderedEXT execution modes.

The PixelInterlockOrderedEXT and PixelInterlockUnorderedEXT execution modes provide mutual exclusion in the critical section for any pair of fragments corresponding to the same pixel, or pixels if the fragment covers more than one pixel. With sample shading enabled, these execution modes are treated like SampleInterlockOrderedEXT or SampleInterlockUnorderedEXT respectively.

The SampleInterlockOrderedEXT and SampleInterlockUnorderedEXT execution modes only provide mutual exclusion for pairs of fragments that both cover at least one common sample in the same pixel; these are recommended for performance if shaders use per-sample data structures. If these execution modes are used in single-sample mode they are treated like PixelInterlockOrderedEXT or PixelInterlockUnorderedEXT respectively.

The ShadingRateInterlockOrderedEXT and ShadingRateInterlockUnorderedEXT execution modes provide mutual exclusion for pairs of fragments that both have at least one common sample in the same pixel, even if none of the common samples are covered by both fragments. With sample shading enabled, these execution modes are treated like SampleInterlockOrderedEXT or SampleInterlockUnorderedEXT respectively.

8.12. Compute Shaders

Compute shaders are invoked via vkCmdDispatch and vkCmdDispatchIndirect commands. In general, they have access to similar resources as shader stages executing as part of a graphics pipeline.

Compute workloads are formed from groups of work items called workgroups and processed by the compute shader in the current compute pipeline. A workgroup is a collection of shader invocations that execute the same shader, potentially in parallel. Compute shaders execute in global workgroups which are divided into a number of local workgroups with a size that can be set by assigning a value to the LocalSize execution mode or via an object decorated by the WorkgroupSize decoration. An invocation within a local workgroup can share data with other members of the local workgroup through shared variables and issue memory and control flow barriers to synchronize with other members of the local workgroup.

8.13. Interpolation Decorations

Interpolation decorations control the behavior of attribute interpolation in the fragment shader stage. Interpolation decorations can be applied to Input storage class variables in the fragment shader stage’s interface, and control the interpolation behavior of those variables.

Inputs that could be interpolated can be decorated by at most one of the following decorations:

Flat: no interpolation
NoPerspective: linear interpolation (for lines and polygons)

Fragment input variables decorated with neither Flat nor NoPerspective use perspective-correct interpolation (for lines and polygons).

The presence of and type of interpolation is controlled by the above interpolation decorations as well as the auxiliary decorations Centroid and Sample.

A variable decorated with Flat will not be interpolated. Instead, it will have the same value for every fragment within a triangle. This value will come from a single provoking vertex. A variable decorated with Flat can also be decorated with Centroid or Sample, which will mean the same thing as decorating it only as Flat.

For fragment shader input variables decorated with neither Centroid nor Sample, the assigned variable may be interpolated anywhere within the fragment and a single value may be assigned to each sample within the fragment.

If a fragment shader input is decorated with Centroid, a single value may be assigned to that variable for all samples in the fragment, but that value must be interpolated to a location that lies in both the fragment and in the primitive being rendered, including any of the fragment’s samples covered by the primitive. Because the location at which the variable is interpolated may be different in neighboring fragments, and derivatives may be computed by computing differences between neighboring fragments, derivatives of centroid-sampled inputs may be less accurate than those for non-centroid interpolated variables. If VkPipelineViewportShadingRateImageStateCreateInfoNV::shadingRateImageEnable is enabled, implementations may estimate derivatives using differencing without dividing by the distance between adjacent sample locations when the fragment size is larger than one pixel. The PostDepthCoverage execution mode does not affect the determination of the centroid location.

If a fragment shader input is decorated with Sample, a separate value must be assigned to that variable for each covered sample in the fragment, and that value must be sampled at the location of the individual sample. When rasterizationSamples is VK_SAMPLE_COUNT_1_BIT, the fragment center must be used for Centroid, Sample, and undecorated attribute interpolation.

Fragment shader inputs that are signed or unsigned integers, integer vectors, or any double-precision floating-point type must be decorated with Flat.

When the VK_AMD_shader_explicit_vertex_parameter device extension is enabled inputs can be also decorated with the CustomInterpAMD interpolation decoration, including fragment shader inputs that are signed or unsigned integers, integer vectors, or any double-precision floating-point type. Inputs decorated with CustomInterpAMD can only be accessed by the extended instruction InterpolateAtVertexAMD and allows accessing the value of the input for individual vertices of the primitive.

When the fragmentShaderBarycentric feature is enabled, inputs can be also decorated with the PerVertexNV interpolation decoration, including fragment shader inputs that are signed or unsigned integers, integer vectors, or any double-precision floating-point type. Inputs decorated with PerVertexNV can only be accessed using an extra array dimension, where the extra index identifies one of the vertices of the primitive that produced the fragment.

8.14. Ray Generation Shaders

A ray generation shader is similar to a compute shader. Its main purpose is to execute ray tracing queries using OpTraceNV instructions and process the results.

8.14.1. Ray Generation Shader Execution

One ray generation shader is executed per ray tracing dispatch. Its location in the shader binding table (see Shader Binding Table for details) is passed directly into vkCmdTraceRaysNV using the raygenShaderBindingTableBuffer and raygenShaderBindingOffset parameters.

8.15. Intersection Shaders

Intersection shaders enable the implementation of arbitrary, application defined geometric primitives. An intersection shader for a primitive is executed whenever its axis-aligned bounding box is hit by a ray.

A built-in intersection shader for triangle primitives that is used automatically whenever geometry of type VK_GEOMETRY_TYPE_TRIANGLES_NV is specified.

Like other ray tracing shader domains, an intersection shader operates on a single ray at a time. It also operates on a single primitive at a time. It is therefore the purpose of an intersection shader to compute the ray-primitive intersections and report them. To report an intersection, the shader calls the OpReportIntersectionNV instruction.

An intersection shader communicates with any-hit and closest shaders by generating attribute values that they can read. Intersection shaders cannot read or modify the ray payload.

8.15.1. Intersection Shader Execution

The order in which intersections are found along a ray, and therefore the order in which intersection shaders are executed, is unspecified.

The intersection shader of the closest AABB which intersects the ray is guaranteed to be executed at some point during traversal, unless the ray is forcibly terminated.

8.16. Any-Hit Shaders

The any-hit shader is executed after the intersection shader reports an intersection that lies within the current [tmin,tmax] of the ray. The main use of any-hit shaders is to programmatically decide whether or not an intersection will be accepted. The intersection will be accepted unless the shader calls the OpIgnoreIntersectionNV instruction.

8.16.1. Any-Hit Shader Execution

The order in which intersections are found along a ray, and therefore the order in which any-hit shaders are executed, is unspecified.

The any-hit shader of the closest hit is guaranteed to be executed at some point during traversal, unless the ray is forcibly terminated.

8.17. Closest Hit Shaders

Closest hit shaders have read-only access to the attributes generated by the corresponding intersection shader, and can read or modify the ray payload. They also have access to a number of system-generated values. Closest hit shaders can call OpTraceNV to recursively trace rays.

8.17.1. Closest Hit Shader Execution

Exactly one closest hit shader is executed when traversal is finished and an intersection has been found and accepted.

8.18. Miss Shaders

Miss shaders can access the ray payload and can trace new rays through the OpTraceNV instruction, but cannot access attributes since they are not associated with an intersection.

8.18.1. Miss Shader Execution

A miss shader is executed instead of a closest hit shader if no intersection was found during traversal.

8.19. Callable Shaders

Callable shaders can access a callable payload that works similarly to ray payloads to do subroutine work.

8.19.1. Callable Shader Execution

A callable shader is executed by calling OpExecuteCallableNV from an allowed shader stage.

8.20. Static Use

A SPIR-V module declares a global object in memory using the OpVariable instruction, which results in a pointer x to that object. A specific entry point in a SPIR-V module is said to statically use that object if that entry point’s call tree contains a function containing a memory instruction or image instruction with x as an id operand. See the “Memory Instructions” and “Image Instructions” subsections of section 3 “Binary Form” of the SPIR-V specification for the complete list of SPIR-V memory instructions.

Static use is not used to control the behavior of variables with Input and Output storage. The effects of those variables are applied based only on whether they are present in a shader entry point’s interface.

8.21. Scope

A scope describes a set of shader invocations, where each such set is a scope instance. Each invocation belongs to one or more scope instances, but belongs to no more than one scope instance for each scope.

The operations available between invocations in a given scope instance vary, with smaller scopes generally able to perform more operations, and with greater efficiency.

8.21.1. Cross Device

All invocations executed in a Vulkan instance fall into a single cross device scope instance.

Whilst the CrossDevice scope is defined in SPIR-V, it is disallowed in Vulkan. API synchronization commands can be used to communicate between devices.

8.21.2. Device

All invocations executed on a single device form a device scope instance.

If the vulkanMemoryModel and vulkanMemoryModelDeviceScope features are enabled, this scope is represented in SPIR-V by the Device Scope, which can be used as a Memory Scope for barrier and atomic operations.

There is no method to synchronize the execution of these invocations within SPIR-V, and this can only be done with API synchronization primitives.

Invocations executing on different devices in a device group operate in separate device scope instances.

8.21.3. Queue Family

Invocations executed by queues in a given queue family form a queue family scope instance.

This scope is identified in SPIR-V as the QueueFamily Scope if the vulkanMemoryModel feature is enabled, or if not, the Device Scope, which can be used as a Memory Scope for barrier and atomic operations.

There is no method to synchronize the execution of these invocations within SPIR-V, and this can only be done with API synchronization primitives.

Each invocation in a queue family scope instance must be in the same device scope instance.

8.21.4. Command

Any shader invocations executed as the result of a single command such as vkCmdDispatch or vkCmdDraw form a command scope instance. For indirect drawing commands with drawCount greater than one, invocations from separate draws are in separate command scope instances.

There is no specific Scope for communication across invocations in a command scope instance. As this has a clear boundary at the API level, coordination here can be performed in the API, rather than in SPIR-V.

Each invocation in a command scope instance must be in the same queue-family scope instance.

For shaders without defined workgroups, this set of invocations forms an invocation group as defined in the SPIR-V specification (see the subsection “Control Flow” of section 2 of the SPIR-V 1.00 Revision 4 specification).

8.21.5. Primitive

Any fragment shader invocations executed as the result of rasterization of a single primitive form a primitive scope instance.

There is no specific Scope for communication across invocations in a primitive scope instance.

Any generated helper invocations are included in this scope instance.

Each invocation in a primitive scope instance must be in the same command scope instance.

Any input variables decorated with Flat are uniform within a primitive scope instance.

8.21.6. Workgroup

A local workgroup is a set of invocations that can synchronize and share data with each other using memory in the Workgroup storage class.

The Workgroup Scope can be used as both an Execution Scope and Memory Scope for barrier and atomic operations.

Each invocation in a local workgroup must be in the same command scope instance.

Only task, mesh, and compute shaders have defined workgroups - other shader types cannot use workgroup functionality. For shaders that have defined workgroups, this set of invocations forms an invocation group as defined in the SPIR-V specification (see the subsection “Control Flow” of section 2 of the SPIR-V 1.00 Revision 4 specification).

8.21.7. Subgroup

A subgroup (see the subsection “Control Flow” of section 2 of the SPIR-V 1.3 Revision 1 specification) is a set of invocations that can synchronize and share data with each other efficiently.

The Subgroup Scope can be used as both an Execution Scope and Memory Scope for barrier and atomic operations. Other subgroup features allow the use of group operations with subgroup scope.

For shaders that have defined workgroups, each invocation in a subgroup must be in the same local workgroup.

In other shader stages, each invocation in a subgroup must be in the same device scope instance.

Only shader stages that support subgroup operations have defined subgroups.

8.21.8. Quad

A quad scope instance is formed of four shader invocations.

In a fragment shader, each invocation in a quad scope instance is formed of invocations in neighboring framebuffer locations (x_i, y_i), where:

i is the index of the invocation within the scope instance.
x₀ = x₁ - 1 = x₂ = x₃ - 1
y₀ = y₁ = y₂ - 1 = y₃ - 1
Each invocation has the same layer and sample indices.

In a compute shader, if the DerivativeGroupQuadsNV execution mode is specified, each invocation in a quad scope instance is formed of invocations with adjacent local invocation IDs (x_i, y_i), where:

i is the index of the invocation within the quad scope instance.
x₀ = x₁ - 1 = x₂ = x₃ - 1
y₀ = y₁ = y₂ - 1 = y₃ - 1
x₀ and y₀ are integer multiples of 2.
Each invocation has the same z coordinate.

In a compute shader, if the DerivativeGroupLinearNV execution mode is specified, each invocation in a quad scope instance is formed of invocations with adjacent local invocation indices (l_i), where:

i is the index of the invocation within the quad scope instance.
l₀ = l₁ - 1 = l₂ - 2 = l₃ - 3
l₀ is an integer multiple of 4.

In all shaders, each invocation in a quad scope instance is formed of invocations in adjacent subgroup invocation indices (s_i), where:

i is the index of the invocation within the quad scope instance.
s₀ = s₁ - 1 = s₂ - 2 = s₃ - 3
s₀ is an integer multiple of 4.

Each invocation in a quad scope instance must be in the same subgroup.

Fragment and compute shaders have defined quad scope instances. If the quadOperationsInAllStages limit is supported, any shader stages that support subgroup operations also have defined quad scope instances.

8.21.9. Fragment Interlock

A fragment interlock scope instance is formed of fragment shader invocations based on their framebuffer locations (x,y,layer,sample), executed by commands inside a single subpass.

The specific set of invocations included varies based on the execution mode as follows:

If the SampleInterlockOrderedEXT or SampleInterlockUnorderedEXT execution modes are used, only invocations with identical framebuffer locations (x,y,layer,sample) are included.
If the PixelInterlockOrderedEXT or PixelInterlockUnorderedEXT execution modes are used, fragments with different sample ids are also included.
If the ShadingRateInterlockOrderedEXT or ShadingRateInterlockUnorderedEXT execution modes are used, fragments from neighbouring framebuffer locations are also included, as determined by the shading rate.

Only fragment shaders with one of the above execution modes have defined fragment interlock scope instances.

There is no specific Scope value for communication across invocations in a fragment interlock scope instance. However, this is implicitly used as a memory scope by OpBeginInvocationInterlockEXT and OpEndInvocationInterlockEXT.

Each invocation in a fragment interlock scope instance must be in the same queue family scope instance.

8.21.10. Invocation

The smallest scope is a single invocation; this is represented by the Invocation Scope in SPIR-V.

Fragment shader invocations must be in a [shaders-scope-primitive primitive scope instance].

Invocations in fragment shaders that have a defined fragment interlock scope must be in a fragment interlock scope instance.

Invocations in shaders that have defined workgroups must be in a local workgroup.

Invocations in shaders that have a defined subgroup scope must be in a subgroup.

Invocations in shaders that have a defined quad scope must be in a quad scope instance.

All invocations in all stages must be in a command scope instance.

8.22. Group Operations

Group operations are executed by multiple invocations within a scope instance; with each invocation involved in calculating the result. This provides a mechanism for efficient communication between invocations in a particular scope instance.

Group operations all take a Scope defining the desired scope instance to operate within. Only the Subgroup scope can be used for these operations; the subgroupSupportedOperations limit defines which types of operation can be used.

8.22.1. Basic Group Operations

Basic group operations include the use of OpGroupNonUniformElect, OpControlBarrier, OpMemoryBarrier, and atomic operations.

OpGroupNonUniformElect can be used to choose a single invocation to perform a task for the whole group. Only the invocation with the lowest id in the group will return true.

The Memory Model appendix defines the operation of barriers and atomics.

8.22.2. Vote Group Operations

The vote group operations allow invocations within a group to compare values across a group. The types of votes enabled are:

Do all active group invocations agree that an expression is true?
Do any active group invocations evaluate an expression to true?
Do all active group invocations have the same value of an expression?

Note

These operations are useful in combination with control flow in that they allow for developers to check whether conditions match across the group and choose potentially faster code-paths in these cases.

8.22.3. Arithmetic Group Operations

The arithmetic group operations allow invocations to perform scans and reductions across a group. The operators supported are add, mul, min, max, and, or, xor.

For reductions, every invocation in a group will obtain the cumulative result of these operators applied to all values in the group. For exclusive scans, each invocation in a group will obtain the cumulative result of these operators applied to all values in invocations with a lower index in the group. Inclusive scans are identical to exclusive scans, except the cumulative result includes the operator applied to the value in the current invocation.

The order in which these operators are applied is implementation-dependent.

8.22.4. Ballot Group Operations

The ballot group operations allow invocations to perform more complex votes across the group. The ballot functionality allows all invocations within a group to provide a boolean value and get as a result what each invocation provided as their boolean value. The broadcast functionality allows values to be broadcast from an invocation to all other invocations within the group.

8.22.5. Shuffle Group Operations

The shuffle group operations allow invocations to read values from other invocations within a group.

8.22.6. Shuffle Relative Group Operations

The shuffle relative group operations allow invocations to read values from other invocations within the group relative to the current invocation in the group. The relative operations supported allow data to be shifted up and down through the invocations within a group.

8.22.7. Clustered Group Operations

The clustered group operations allow invocations to perform an operation among partitions of a group, such that the operation is only performed within the group invocations within a partition. The partitions for clustered group operations are consecutive power-of-two size groups of invocations and the cluster size must be known at pipeline creation time. The operations supported are add, mul, min, max, and, or, xor.

8.23. Quad Group Operations

Quad group operations (OpGroupNonUniformQuad*) are a specialized type of group operations that only operate on quad scope instances. Whilst these instructions do include a Scope parameter, this scope is always overridden; only the quad scope instance is included in its execution scope.

Fragment shaders that statically execute quad group operations must launch sufficient invocations to ensure their correct operation; additional helper invocations are launched for framebuffer locations not covered by rasterized fragments if necessary.

The index used to select participating invocations is i, as described for a quad scope instance. For OpGroupNonUniformQuadBroadcast this value is equal to Index. For OpGroupNonUniformQuadSwap, it’s equal to the implicit Index used by each participating invocation.

8.24. Derivative Operations

Derivative operations calculate the partial derivative for an expression P as a function of an invocation’s x and y coordinates.

Derivative operations operate on a set of invocations known as a derivative group as defined in the SPIR-V specification (see the subsection “Control Flow” of section 2 of the SPIR-V 1.00 Revision 4 specification). A derivative group is equivalent to the local workgroup for a compute shader invocation, or the primitive scope instance for a fragment shader invocation.

Derivatives are calculated assuming that P is piecewise linear and continuous within the derivative group. All dynamic instances of explicit derivative instructions (OpDPdx*, OpDPdy*, and OpFwidth*) must be executed in control flow that is uniform within a derivative group. For other derivative operations, results are undefined if a dynamic instance is executed in control flow is not uniform within the derivative group.

Fragment shaders that statically execute derivative operations must launch sufficient invocations to ensure their correct operation; additional helper invocations are launched for framebuffer locations not covered by rasterized fragments if necessary.

Note

In a compute shader, it is the application’s responsibility to ensure that sufficient invocations are launched.

Derivative operations calculate their results as the difference between the result of P across invocations in the quad. For fine derivative operations (OpDPdxFine and OpDPdyFine), the values of DPdx(P_i) are calculated as

: DPdx(P₀) = DPdx(P₁) = P₁ - P₀
: DPdx(P₂) = DPdx(P₃) = P₃ - P₂

and the values of DPdy(P_i) are calculated as

: DPdy(P₀) = DPdy(P₂) = P₂ - P₀
: DPdy(P₁) = DPdy(P₃) = P₃ - P₁

where i is the index of each invocation as described in Quad.

Coarse derivative operations (OpDPdxCoarse and OpDPdyCoarse), calculate their results in roughly the same manner, but may only calculate two values instead of four (one for each of DPdx and DPdy), reusing the same result no matter the originating invocation. If an implementation does this, it should use the fine derivative calculations described for P₀.

The results for OpDPdx and OpDPdy may be calculated as either fine or coarse derivatives, with implementations favouring the most efficient approach. Implementations must choose coarse or fine consistently between the two.

Executing OpFwidthFine, OpFwidthCoarse, or OpFwidth is equivalent to executing the corresponding OpDPdx* and OpDPdy* instructions, taking the absolute value of the results, and summing them.

Executing a OpImage*Sample*ImplicitLod instruction is equivalent to executing OpDPdx(Coordinate) and OpDPdy(Coordinate), and passing the results as the Grad operands dx and dy.

Note

It is expected that using the ImplicitLod variants of sampling functions will be substantially more efficient than using the ExplicitLod variants with explicitly generated derivatives.

8.25. Helper Invocations

When performing derivative or quad group operations in a fragment shader, additional invocations may be spawned in order to ensure correct results. These additional invocations are known as helper invocations and can be identified by a non-zero value in the HelperInvocation built-in. Stores and atomics performed by helper invocations must not have any effect on memory, and values returned by atomic instructions in helper invocations are undefined.

Helper invocations may become inactive at any time for any reason, with one exception. If a helper invocation would be active if it were not a helper invocation, it must be active for derivative and quad group operations.

Helper invocations may become permanently inactive if all invocations in a quad scope instance become helper invocations.

8.26. Cooperative Matrices

A cooperative matrix type is a SPIR-V type where the storage for and computations performed on the matrix are spread across the invocations in a scope instance. These types give the implementation freedom in how to optimize matrix multiplies.

SPIR-V defines the types and instructions, but does not specify rules about what sizes/combinations are valid, and it is expected that different implementations may support different sizes.

To enumerate the supported cooperative matrix types and operations, call:

VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pPropertyCount,
    VkCooperativeMatrixPropertiesNV*            pProperties);

physicalDevice is the physical device.
pPropertyCount is a pointer to an integer related to the number of cooperative matrix properties available or queried.
pProperties is either NULL or a pointer to an array of VkCooperativeMatrixPropertiesNV structures.

If pProperties is NULL, then the number of cooperative matrix 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 cooperative matrix properties available, at most pPropertyCount structures will be written. If pPropertyCount is smaller than the number of cooperative matrix properties available, VK_INCOMPLETE will be returned instead of VK_SUCCESS, to indicate that not all the available cooperative matrix properties were returned.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceCooperativeMatrixPropertiesNV-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceCooperativeMatrixPropertiesNV-pPropertyCount-parameter
pPropertyCount must be a valid pointer to a uint32_t value
VUID-vkGetPhysicalDeviceCooperativeMatrixPropertiesNV-pProperties-parameter
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkCooperativeMatrixPropertiesNV structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Each VkCooperativeMatrixPropertiesNV structure describes a single supported combination of types for a matrix multiply/add operation (OpCooperativeMatrixMulAddNV). The multiply can be described in terms of the following variables and types (in SPIR-V pseudocode):

    %A is of type OpTypeCooperativeMatrixNV %AType %scope %MSize %KSize
    %B is of type OpTypeCooperativeMatrixNV %BType %scope %KSize %NSize
    %C is of type OpTypeCooperativeMatrixNV %CType %scope %MSize %NSize
    %D is of type OpTypeCooperativeMatrixNV %DType %scope %MSize %NSize

    %D = %A * %B + %C // using OpCooperativeMatrixMulAddNV

A matrix multiply with these dimensions is known as an MxNxK matrix multiply.

The VkCooperativeMatrixPropertiesNV structure is defined as:

typedef struct VkCooperativeMatrixPropertiesNV {
    VkStructureType      sType;
    void*                pNext;
    uint32_t             MSize;
    uint32_t             NSize;
    uint32_t             KSize;
    VkComponentTypeNV    AType;
    VkComponentTypeNV    BType;
    VkComponentTypeNV    CType;
    VkComponentTypeNV    DType;
    VkScopeNV            scope;
} VkCooperativeMatrixPropertiesNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
MSize is the number of rows in matrices A, C, and D.
KSize is the number of columns in matrix A and rows in matrix B.
NSize is the number of columns in matrices B, C, D.
AType is the component type of matrix A, of type VkComponentTypeNV.
BType is the component type of matrix B, of type VkComponentTypeNV.
CType is the component type of matrix C, of type VkComponentTypeNV.
DType is the component type of matrix D, of type VkComponentTypeNV.
scope is the scope of all the matrix types, of type VkScopeNV.

If some types are preferred over other types (e.g. for performance), they should appear earlier in the list enumerated by vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.

At least one entry in the list must have power of two values for all of MSize, KSize, and NSize.

Valid Usage (Implicit)

VUID-VkCooperativeMatrixPropertiesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV
VUID-VkCooperativeMatrixPropertiesNV-pNext-pNext
pNext must be NULL
VUID-VkCooperativeMatrixPropertiesNV-AType-parameter
AType must be a valid VkComponentTypeNV value
VUID-VkCooperativeMatrixPropertiesNV-BType-parameter
BType must be a valid VkComponentTypeNV value
VUID-VkCooperativeMatrixPropertiesNV-CType-parameter
CType must be a valid VkComponentTypeNV value
VUID-VkCooperativeMatrixPropertiesNV-DType-parameter
DType must be a valid VkComponentTypeNV value
VUID-VkCooperativeMatrixPropertiesNV-scope-parameter
scope must be a valid VkScopeNV value

Possible values for VkScopeNV include:

typedef enum VkScopeNV {
    VK_SCOPE_DEVICE_NV = 1,
    VK_SCOPE_WORKGROUP_NV = 2,
    VK_SCOPE_SUBGROUP_NV = 3,
    VK_SCOPE_QUEUE_FAMILY_NV = 5,
    VK_SCOPE_MAX_ENUM_NV = 0x7FFFFFFF
} VkScopeNV;

VK_SCOPE_DEVICE_NV corresponds to SPIR-V Device scope.
VK_SCOPE_WORKGROUP_NV corresponds to SPIR-V Workgroup scope.
VK_SCOPE_SUBGROUP_NV corresponds to SPIR-V Subgroup scope.
VK_SCOPE_QUEUE_FAMILY_NV corresponds to SPIR-V QueueFamily scope.

All enum values match the corresponding SPIR-V value.

Possible values for VkComponentTypeNV include:

typedef enum VkComponentTypeNV {
    VK_COMPONENT_TYPE_FLOAT16_NV = 0,
    VK_COMPONENT_TYPE_FLOAT32_NV = 1,
    VK_COMPONENT_TYPE_FLOAT64_NV = 2,
    VK_COMPONENT_TYPE_SINT8_NV = 3,
    VK_COMPONENT_TYPE_SINT16_NV = 4,
    VK_COMPONENT_TYPE_SINT32_NV = 5,
    VK_COMPONENT_TYPE_SINT64_NV = 6,
    VK_COMPONENT_TYPE_UINT8_NV = 7,
    VK_COMPONENT_TYPE_UINT16_NV = 8,
    VK_COMPONENT_TYPE_UINT32_NV = 9,
    VK_COMPONENT_TYPE_UINT64_NV = 10,
    VK_COMPONENT_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
} VkComponentTypeNV;

VK_COMPONENT_TYPE_FLOAT16_NV corresponds to SPIR-V OpTypeFloat 16.
VK_COMPONENT_TYPE_FLOAT32_NV corresponds to SPIR-V OpTypeFloat 32.
VK_COMPONENT_TYPE_FLOAT64_NV corresponds to SPIR-V OpTypeFloat 64.
VK_COMPONENT_TYPE_SINT8_NV corresponds to SPIR-V OpTypeInt 8 1.
VK_COMPONENT_TYPE_SINT16_NV corresponds to SPIR-V OpTypeInt 16 1.
VK_COMPONENT_TYPE_SINT32_NV corresponds to SPIR-V OpTypeInt 32 1.
VK_COMPONENT_TYPE_SINT64_NV corresponds to SPIR-V OpTypeInt 64 1.
VK_COMPONENT_TYPE_UINT8_NV corresponds to SPIR-V OpTypeInt 8 0.
VK_COMPONENT_TYPE_UINT16_NV corresponds to SPIR-V OpTypeInt 16 0.
VK_COMPONENT_TYPE_UINT32_NV corresponds to SPIR-V OpTypeInt 32 0.
VK_COMPONENT_TYPE_UINT64_NV corresponds to SPIR-V OpTypeInt 64 0.

8.27. Validation Cache

Validation cache objects allow the result of internal validation to be reused, both within a single application run and between multiple runs. Reuse within a single run is achieved by passing the same validation cache object when creating supported Vulkan objects. Reuse across runs of an application is achieved by retrieving validation cache contents in one run of an application, saving the contents, and using them to preinitialize a validation cache on a subsequent run. The contents of the validation cache objects are managed by the validation layers. Applications can manage the host memory consumed by a validation cache object and control the amount of data retrieved from a validation cache object.

Validation cache objects are represented by VkValidationCacheEXT handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT)

To create validation cache objects, call:

VkResult vkCreateValidationCacheEXT(
    VkDevice                                    device,
    const VkValidationCacheCreateInfoEXT*       pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkValidationCacheEXT*                       pValidationCache);

device is the logical device that creates the validation cache object.
pCreateInfo is a pointer to a VkValidationCacheCreateInfoEXT structure containing the initial parameters for the validation cache object.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pValidationCache is a pointer to a VkValidationCacheEXT handle in which the resulting validation cache object is returned.

Note

Applications can track and manage the total host memory size of a validation cache object using the pAllocator. Applications can limit the amount of data retrieved from a validation cache object in vkGetValidationCacheDataEXT. Implementations should not internally limit the total number of entries added to a validation cache object or the total host memory consumed.

Once created, a validation cache can be passed to the vkCreateShaderModule command by adding this object to the VkShaderModuleCreateInfo structure’s pNext chain. If a VkShaderModuleValidationCacheCreateInfoEXT object is included in the VkShaderModuleCreateInfo::pNext chain, and its validationCache field is not VK_NULL_HANDLE, the implementation will query it for possible reuse opportunities and update it with new content. The use of the validation cache object in these commands is internally synchronized, and the same validation 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 vkCreateShaderModule command.

Valid Usage (Implicit)

VUID-vkCreateValidationCacheEXT-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateValidationCacheEXT-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkValidationCacheCreateInfoEXT structure
VUID-vkCreateValidationCacheEXT-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateValidationCacheEXT-pValidationCache-parameter
pValidationCache must be a valid pointer to a VkValidationCacheEXT handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY

The VkValidationCacheCreateInfoEXT structure is defined as:

typedef struct VkValidationCacheCreateInfoEXT {
    VkStructureType                    sType;
    const void*                        pNext;
    VkValidationCacheCreateFlagsEXT    flags;
    size_t                             initialDataSize;
    const void*                        pInitialData;
} VkValidationCacheCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
initialDataSize is the number of bytes in pInitialData. If initialDataSize is zero, the validation cache will initially be empty.
pInitialData is a pointer to previously retrieved validation cache data. If the validation cache data is incompatible (as defined below) with the device, the validation cache will be initially empty. If initialDataSize is zero, pInitialData is ignored.

Valid Usage

VUID-VkValidationCacheCreateInfoEXT-initialDataSize-01534
If initialDataSize is not 0, it must be equal to the size of pInitialData, as returned by vkGetValidationCacheDataEXT when pInitialData was originally retrieved
VUID-VkValidationCacheCreateInfoEXT-initialDataSize-01535
If initialDataSize is not 0, pInitialData must have been retrieved from a previous call to vkGetValidationCacheDataEXT

Valid Usage (Implicit)

VUID-VkValidationCacheCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT
VUID-VkValidationCacheCreateInfoEXT-pNext-pNext
pNext must be NULL
VUID-VkValidationCacheCreateInfoEXT-flags-zerobitmask
flags must be 0
VUID-VkValidationCacheCreateInfoEXT-pInitialData-parameter
If initialDataSize is not 0, pInitialData must be a valid pointer to an array of initialDataSize bytes

typedef VkFlags VkValidationCacheCreateFlagsEXT;

VkValidationCacheCreateFlagsEXT is a bitmask type for setting a mask, but is currently reserved for future use.

Validation cache objects can be merged using the command:

VkResult vkMergeValidationCachesEXT(
    VkDevice                                    device,
    VkValidationCacheEXT                        dstCache,
    uint32_t                                    srcCacheCount,
    const VkValidationCacheEXT*                 pSrcCaches);

device is the logical device that owns the validation cache objects.
dstCache is the handle of the validation cache to merge results into.
srcCacheCount is the length of the pSrcCaches array.
pSrcCaches is a pointer to an array of validation cache handles, which will be merged into dstCache. The previous contents of dstCache are included after the merge.

Note

The details of the merge operation are implementation dependent, but implementations should merge the contents of the specified validation caches and prune duplicate entries.

Valid Usage

VUID-vkMergeValidationCachesEXT-dstCache-01536
dstCache must not appear in the list of source caches

Valid Usage (Implicit)

VUID-vkMergeValidationCachesEXT-device-parameter
device must be a valid VkDevice handle
VUID-vkMergeValidationCachesEXT-dstCache-parameter
dstCache must be a valid VkValidationCacheEXT handle
VUID-vkMergeValidationCachesEXT-pSrcCaches-parameter
pSrcCaches must be a valid pointer to an array of srcCacheCount valid VkValidationCacheEXT handles
VUID-vkMergeValidationCachesEXT-srcCacheCount-arraylength
srcCacheCount must be greater than 0
VUID-vkMergeValidationCachesEXT-dstCache-parent
dstCache must have been created, allocated, or retrieved from device
VUID-vkMergeValidationCachesEXT-pSrcCaches-parent
Each element of pSrcCaches must have been created, allocated, or retrieved from device

Host Synchronization

Host access to dstCache must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Data can be retrieved from a validation cache object using the command:

VkResult vkGetValidationCacheDataEXT(
    VkDevice                                    device,
    VkValidationCacheEXT                        validationCache,
    size_t*                                     pDataSize,
    void*                                       pData);

device is the logical device that owns the validation cache.
validationCache is the validation cache to retrieve data from.
pDataSize is a pointer to a value related to the amount of data in the validation cache, as described below.
pData is either NULL or a pointer to a buffer.

If pData is NULL, then the maximum size of the data that can be retrieved from the validation 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 pDataSize is less than the maximum size that can be retrieved by the validation cache, at most pDataSize bytes will be written to pData, and vkGetValidationCacheDataEXT will return VK_INCOMPLETE. Any data written to pData is valid and can be provided as the pInitialData member of the VkValidationCacheCreateInfoEXT structure passed to vkCreateValidationCacheEXT.

Two calls to vkGetValidationCacheDataEXT with the same parameters must retrieve the same data unless a command that modifies the contents of the cache is called between them.

Applications can store the data retrieved from the validation cache, and use these data, possibly in a future run of the application, to populate new validation cache objects. The results of validation, 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:

Table 11. Layout for validation cache header version `VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT`
Offset	Size	Meaning
0	4	length in bytes of the entire validation cache header written as a stream of bytes, with the least significant byte first
4	4	a VkValidationCacheHeaderVersionEXT value written as a stream of bytes, with the least significant byte first
8	`VK_UUID_SIZE`	a layer commit ID expressed as a UUID, which uniquely identifies the version of the validation layers used to generate these validation results

The first four bytes encode the length of the entire validation cache header, in bytes. This value includes all fields in the header including the validation cache version field and the size of the length field.

The next four bytes encode the validation cache version, as described for VkValidationCacheHeaderVersionEXT. A consumer of the validation cache should use the cache version to interpret the remainder of the cache header.

If pDataSize is less than what is necessary to store this header, nothing will be written to pData and zero will be written to pDataSize.

Valid Usage (Implicit)

VUID-vkGetValidationCacheDataEXT-device-parameter
device must be a valid VkDevice handle
VUID-vkGetValidationCacheDataEXT-validationCache-parameter
validationCache must be a valid VkValidationCacheEXT handle
VUID-vkGetValidationCacheDataEXT-pDataSize-parameter
pDataSize must be a valid pointer to a size_t value
VUID-vkGetValidationCacheDataEXT-pData-parameter
If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of pDataSize bytes
VUID-vkGetValidationCacheDataEXT-validationCache-parent
validationCache must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Possible values of the second group of four bytes in the header returned by vkGetValidationCacheDataEXT, encoding the validation cache version, are:

typedef enum VkValidationCacheHeaderVersionEXT {
    VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1,
    VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF
} VkValidationCacheHeaderVersionEXT;

VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT specifies version one of the validation cache.

To destroy a validation cache, call:

void vkDestroyValidationCacheEXT(
    VkDevice                                    device,
    VkValidationCacheEXT                        validationCache,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the validation cache object.
validationCache is the handle of the validation cache to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyValidationCacheEXT-validationCache-01537
If VkAllocationCallbacks were provided when validationCache was created, a compatible set of callbacks must be provided here
VUID-vkDestroyValidationCacheEXT-validationCache-01538
If no VkAllocationCallbacks were provided when validationCache was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyValidationCacheEXT-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyValidationCacheEXT-validationCache-parameter
If validationCache is not VK_NULL_HANDLE, validationCache must be a valid VkValidationCacheEXT handle
VUID-vkDestroyValidationCacheEXT-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyValidationCacheEXT-validationCache-parent
If validationCache is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to validationCache must be externally synchronized

9. Pipelines

The following figure shows a block diagram of the Vulkan pipelines. Some Vulkan commands specify geometric objects to be drawn or computational work to be performed, while others specify state controlling how objects are handled by the various pipeline stages, or control data transfer between memory organized as images and buffers. Commands are effectively sent through a processing pipeline, either a graphics pipeline, a compute pipeline, or a ray tracing pipeline.

The graphics pipeline can be operated in two modes, as either primitive shading or mesh shading pipeline.

Primitive Shading

The first stage of the graphics pipeline (Input Assembler) assembles vertices to form geometric primitives such as points, lines, and triangles, based on a requested primitive topology. In the next stage (Vertex Shader) vertices can be transformed, computing positions and attributes for each vertex. If tessellation and/or geometry shaders are supported, they can then generate multiple primitives from a single input primitive, possibly changing the primitive topology or generating additional attribute data in the process.

Mesh Shading

When using the mesh shading pipeline input primitives are not assembled implicitly, but explicitly through the (Mesh Shader). The work on the mesh pipeline is initiated by the application drawing a set of mesh tasks.

If an optional (Task Shader) is active, each task triggers the execution of a task shader workgroup that will generate a new set of tasks upon completion. Each of these spawned tasks, or each of the original dispatched tasks if no task shader is present, triggers the execution of a mesh shader workgroup that produces an output mesh with a variable-sized number of primitives assembled from vertices stored in the output mesh.

Common

The final resulting primitives are clipped to a clip volume in preparation for the next stage, Rasterization. The rasterizer produces a series of framebuffer addresses and values using a two-dimensional description of a point, line segment, or triangle. Each fragment so produced is fed to the next stage (Fragment Shader) that performs operations on individual fragments before they finally alter the framebuffer. These operations include conditional updates into the framebuffer based on incoming and previously stored depth values (to effect depth buffering), blending of incoming fragment colors with stored colors, as well as masking, stenciling, and other logical operations on fragment values.

Framebuffer operations read and write the color and depth/stencil attachments of the framebuffer for a given subpass of a render pass instance. The attachments can be used as input attachments in the fragment shader in a later subpass of the same render pass.

The compute pipeline is a separate pipeline from the graphics pipeline, which operates on one-, two-, or three-dimensional workgroups which can read from and write to buffer and image memory.

This ordering is meant only as a tool for describing Vulkan, not as a strict rule of how Vulkan is implemented, and we present it only as a means to organize the various operations of the pipelines. Actual ordering guarantees between pipeline stages are explained in detail in the synchronization chapter.

Figure 2. Block diagram of the Vulkan pipeline

Each pipeline is controlled by a monolithic object created from a description of all of the shader stages and any relevant fixed-function stages. Linking the whole pipeline together allows the optimization of shaders based on their input/outputs and eliminates expensive draw time state validation.

A pipeline object is bound to the current state using vkCmdBindPipeline. Any pipeline object state that is specified as dynamic is not applied to the current state when the pipeline object is bound, but is instead set by dynamic state setting commands.

No state, including dynamic state, is inherited from one command buffer to another.

Compute, graphics, and ray tracing pipelines are each represented by VkPipeline handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)

9.1. Compute Pipelines

Compute pipelines consist of a single static compute shader stage and the pipeline layout.

The compute pipeline represents 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.

To create compute pipelines, call:

VkResult vkCreateComputePipelines(
    VkDevice                                    device,
    VkPipelineCache                             pipelineCache,
    uint32_t                                    createInfoCount,
    const VkComputePipelineCreateInfo*          pCreateInfos,
    const VkAllocationCallbacks*                pAllocator,
    VkPipeline*                                 pPipelines);

device is the logical device that creates the compute pipelines.
pipelineCache is either VK_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.
createInfoCount is the length of the pCreateInfos and pPipelines arrays.
pCreateInfos is a pointer to an array of VkComputePipelineCreateInfo structures.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

pPipelines is a pointer to an array of VkPipeline handles in which the resulting compute pipeline objects are returned.

editing-note

TODO (Jon) - Should we say something like “the i’th element of the pPipelines array is created based on the corresponding element of the pCreateInfos array”? Also for vkCreateGraphicsPipelines below.

Valid Usage

VUID-vkCreateComputePipelines-flags-00695
If the flags member of any element of pCreateInfos contains the VK_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
VUID-vkCreateComputePipelines-flags-00696
If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set

Valid Usage (Implicit)

VUID-vkCreateComputePipelines-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateComputePipelines-pipelineCache-parameter
If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle
VUID-vkCreateComputePipelines-pCreateInfos-parameter
pCreateInfos must be a valid pointer to an array of createInfoCount valid VkComputePipelineCreateInfo structures
VUID-vkCreateComputePipelines-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateComputePipelines-pPipelines-parameter
pPipelines must be a valid pointer to an array of createInfoCount VkPipeline handles
VUID-vkCreateComputePipelines-createInfoCount-arraylength
createInfoCount must be greater than 0
VUID-vkCreateComputePipelines-pipelineCache-parent
If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INVALID_SHADER_NV

The VkComputePipelineCreateInfo structure is defined as:

typedef struct VkComputePipelineCreateInfo {
    VkStructureType                    sType;
    const void*                        pNext;
    VkPipelineCreateFlags              flags;
    VkPipelineShaderStageCreateInfo    stage;
    VkPipelineLayout                   layout;
    VkPipeline                         basePipelineHandle;
    int32_t                            basePipelineIndex;
} VkComputePipelineCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkPipelineCreateFlagBits specifying how the pipeline will be generated.
stage is a VkPipelineShaderStageCreateInfo structure describing the compute shader.
layout is the description of binding locations used by both the pipeline and descriptor sets used with the pipeline.
basePipelineHandle is a pipeline to derive from
basePipelineIndex is an index into the pCreateInfos parameter to use as a pipeline to derive from

The parameters basePipelineHandle and basePipelineIndex are described in more detail in Pipeline Derivatives.

Valid Usage

VUID-VkComputePipelineCreateInfo-flags-00697
If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a compute VkPipeline
VUID-VkComputePipelineCreateInfo-flags-00698
If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command’s pCreateInfos parameter
VUID-VkComputePipelineCreateInfo-flags-00699
If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE
VUID-VkComputePipelineCreateInfo-flags-00700
If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1
VUID-VkComputePipelineCreateInfo-stage-00701
The stage member of stage must be VK_SHADER_STAGE_COMPUTE_BIT
VUID-VkComputePipelineCreateInfo-stage-00702
The shader code for the entry point identified by stage and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter
VUID-VkComputePipelineCreateInfo-layout-00703
layout must be consistent with the layout of the compute shader specified in stage
VUID-VkComputePipelineCreateInfo-layout-01687
The number of resources in layout accessible to the compute shader stage must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources

Valid Usage (Implicit)

VUID-VkComputePipelineCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
VUID-VkComputePipelineCreateInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineCompilerControlCreateInfoAMD or VkPipelineCreationFeedbackCreateInfoEXT
VUID-VkComputePipelineCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkComputePipelineCreateInfo-flags-parameter
flags must be a valid combination of VkPipelineCreateFlagBits values
VUID-VkComputePipelineCreateInfo-stage-parameter
stage must be a valid VkPipelineShaderStageCreateInfo structure
VUID-VkComputePipelineCreateInfo-layout-parameter
layout must be a valid VkPipelineLayout handle
VUID-VkComputePipelineCreateInfo-commonparent
Both of basePipelineHandle, and layout that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

The VkPipelineShaderStageCreateInfo structure is defined as:

typedef struct VkPipelineShaderStageCreateInfo {
    VkStructureType                     sType;
    const void*                         pNext;
    VkPipelineShaderStageCreateFlags    flags;
    VkShaderStageFlagBits               stage;
    VkShaderModule                      module;
    const char*                         pName;
    const VkSpecializationInfo*         pSpecializationInfo;
} VkPipelineShaderStageCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkPipelineShaderStageCreateFlagBits specifying how the pipeline shader stage will be generated.
stage is a VkShaderStageFlagBits value specifying a single pipeline stage.
module is a VkShaderModule object containing the shader for this stage.
pName is a pointer to a null-terminated UTF-8 string specifying the entry point name of the shader for this stage.
pSpecializationInfo is a pointer to a VkSpecializationInfo structure, as described in Specialization Constants, or NULL.

Valid Usage

VUID-VkPipelineShaderStageCreateInfo-stage-00704
If the geometry shaders feature is not enabled, stage must not be VK_SHADER_STAGE_GEOMETRY_BIT
VUID-VkPipelineShaderStageCreateInfo-stage-00705
If the tessellation shaders feature is not enabled, stage must not be VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT
VUID-VkPipelineShaderStageCreateInfo-stage-02091
If the mesh shader feature is not enabled, stage must not be VK_SHADER_STAGE_MESH_BIT_NV
VUID-VkPipelineShaderStageCreateInfo-stage-02092
If the task shader feature is not enabled, stage must not be VK_SHADER_STAGE_TASK_BIT_NV
VUID-VkPipelineShaderStageCreateInfo-stage-00706
stage must not be VK_SHADER_STAGE_ALL_GRAPHICS, or VK_SHADER_STAGE_ALL
VUID-VkPipelineShaderStageCreateInfo-pName-00707
pName must be the name of an OpEntryPoint in module with an execution model that matches stage
VUID-VkPipelineShaderStageCreateInfo-maxClipDistances-00708
If the identified entry point includes any variable in its interface that is declared with the ClipDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxClipDistances
VUID-VkPipelineShaderStageCreateInfo-maxCullDistances-00709
If the identified entry point includes any variable in its interface that is declared with the CullDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxCullDistances
VUID-VkPipelineShaderStageCreateInfo-maxCombinedClipAndCullDistances-00710
If the identified entry point includes any variables in its interface that are declared with the ClipDistance or CullDistance BuiltIn decoration, those variables must not have array sizes which sum to more than VkPhysicalDeviceLimits::maxCombinedClipAndCullDistances
VUID-VkPipelineShaderStageCreateInfo-maxSampleMaskWords-00711
If the identified entry point includes any variable in its interface that is declared with the SampleMask BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxSampleMaskWords
VUID-VkPipelineShaderStageCreateInfo-stage-00712
If stage is VK_SHADER_STAGE_VERTEX_BIT, the identified entry point must not include any input variable in its interface that is decorated with CullDistance
VUID-VkPipelineShaderStageCreateInfo-stage-00713
If stage is VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, and the identified entry point has an OpExecutionMode instruction that specifies a patch size with OutputVertices, the patch size must be greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize
VUID-VkPipelineShaderStageCreateInfo-stage-00714
If stage is VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction that specifies a maximum output vertex count that is greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxGeometryOutputVertices
VUID-VkPipelineShaderStageCreateInfo-stage-00715
If stage is VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction that specifies an invocation count that is greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxGeometryShaderInvocations
VUID-VkPipelineShaderStageCreateInfo-stage-02596
If stage is a vertex processing stage, and the identified entry point writes to Layer for any primitive, it must write the same value to Layer for all vertices of a given primitive
VUID-VkPipelineShaderStageCreateInfo-stage-02597
If stage is a vertex processing stage, and the identified entry point writes to ViewportIndex for any primitive, it must write the same value to ViewportIndex for all vertices of a given primitive
VUID-VkPipelineShaderStageCreateInfo-stage-00718
If stage is VK_SHADER_STAGE_FRAGMENT_BIT, the identified entry point must not include any output variables in its interface decorated with CullDistance
VUID-VkPipelineShaderStageCreateInfo-stage-00719
If stage is VK_SHADER_STAGE_FRAGMENT_BIT, and the identified entry point writes to FragDepth in any execution path, it must write to FragDepth in all execution paths
VUID-VkPipelineShaderStageCreateInfo-stage-01511
If stage is VK_SHADER_STAGE_FRAGMENT_BIT, and the identified entry point writes to FragStencilRefEXT in any execution path, it must write to FragStencilRefEXT in all execution paths
VUID-VkPipelineShaderStageCreateInfo-stage-02093
If stage is VK_SHADER_STAGE_MESH_BIT_NV, the identified entry point must have an OpExecutionMode instruction that specifies a maximum output vertex count, OutputVertices, that is greater than 0 and less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputVertices.
VUID-VkPipelineShaderStageCreateInfo-stage-02094
If stage is VK_SHADER_STAGE_MESH_BIT_NV, the identified entry point must have an OpExecutionMode instruction that specifies a maximum output primitive count, OutputPrimitivesNV, that is greater than 0 and less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputPrimitives.
VUID-VkPipelineShaderStageCreateInfo-flags-02784
If flags has the VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT flag set, the subgroupSizeControl feature must be enabled.
VUID-VkPipelineShaderStageCreateInfo-flags-02785
If flags has the VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT flag set, the computeFullSubgroups feature must be enabled.
VUID-VkPipelineShaderStageCreateInfo-pNext-02754
If a VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure is included in the pNext chain, flags must not have the VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT flag set.
VUID-VkPipelineShaderStageCreateInfo-pNext-02755
If a VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure is included in the pNext chain, the subgroupSizeControl feature must be enabled, and stage must be a valid bit specified in requiredSubgroupSizeStages.
VUID-VkPipelineShaderStageCreateInfo-pNext-02756
If a VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure is included in the pNext chain and stage is VK_SHADER_STAGE_COMPUTE_BIT, the local workgroup size of the shader must be less than or equal to the product of VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::requiredSubgroupSize and maxComputeWorkgroupSubgroups.
VUID-VkPipelineShaderStageCreateInfo-pNext-02757
If a VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure is included in the pNext chain, and flags has the VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT flag set, the local workgroup size in the X dimension of the pipeline must be a multiple of VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::requiredSubgroupSize.
VUID-VkPipelineShaderStageCreateInfo-flags-02758
If flags has both the VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT and VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT flags set, the local workgroup size in the X dimension of the pipeline must be a multiple of maxSubgroupSize.
VUID-VkPipelineShaderStageCreateInfo-flags-02759
If flags has the VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT flag set and flags does not have the VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT flag set and no VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure is included in the pNext chain, the local workgroup size in the X dimension of the pipeline must be a multiple of subgroupSize.

Valid Usage (Implicit)

VUID-VkPipelineShaderStageCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
VUID-VkPipelineShaderStageCreateInfo-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
VUID-VkPipelineShaderStageCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkPipelineShaderStageCreateInfo-flags-parameter
flags must be a valid combination of VkPipelineShaderStageCreateFlagBits values
VUID-VkPipelineShaderStageCreateInfo-stage-parameter
stage must be a valid VkShaderStageFlagBits value
VUID-VkPipelineShaderStageCreateInfo-module-parameter
module must be a valid VkShaderModule handle
VUID-VkPipelineShaderStageCreateInfo-pName-parameter
pName must be a null-terminated UTF-8 string
VUID-VkPipelineShaderStageCreateInfo-pSpecializationInfo-parameter
If pSpecializationInfo is not NULL, pSpecializationInfo must be a valid pointer to a valid VkSpecializationInfo structure

typedef VkFlags VkPipelineShaderStageCreateFlags;

VkPipelineShaderStageCreateFlags is a bitmask type for setting a mask of zero or more VkPipelineShaderStageCreateFlagBits.

Possible values of the flags member of VkPipelineShaderStageCreateInfo specifying how a pipeline shader stage is created, are:

typedef enum VkPipelineShaderStageCreateFlagBits {
    VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000001,
    VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000002,
    VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkPipelineShaderStageCreateFlagBits;

VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT specifies that the SubgroupSize may vary in the shader stage.
VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT specifies that the subgroup sizes must be launched with all invocations active in the compute stage.

Note

If VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT and VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT are specified and minSubgroupSize does not equal maxSubgroupSize and no required subgroup size is specified, then the only way to guarantee that the 'X' dimension of the local workgroup size is a multiple of SubgroupSize is to make it a multiple of maxSubgroupSize. Under these conditions, you are guaranteed full subgroups but not any particular subgroup size.

Commands and structures which need to specify one or more shader stages do so using a bitmask whose bits correspond to stages. Bits which can be set to specify shader stages are:

typedef enum VkShaderStageFlagBits {
    VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
    VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
    VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
    VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
    VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
    VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
    VK_SHADER_STAGE_RAYGEN_BIT_NV = 0x00000100,
    VK_SHADER_STAGE_ANY_HIT_BIT_NV = 0x00000200,
    VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = 0x00000400,
    VK_SHADER_STAGE_MISS_BIT_NV = 0x00000800,
    VK_SHADER_STAGE_INTERSECTION_BIT_NV = 0x00001000,
    VK_SHADER_STAGE_CALLABLE_BIT_NV = 0x00002000,
    VK_SHADER_STAGE_TASK_BIT_NV = 0x00000040,
    VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080,
    VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkShaderStageFlagBits;

VK_SHADER_STAGE_VERTEX_BIT specifies the vertex stage.
VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT specifies the tessellation control stage.
VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT specifies the tessellation evaluation stage.
VK_SHADER_STAGE_GEOMETRY_BIT specifies the geometry stage.
VK_SHADER_STAGE_FRAGMENT_BIT specifies the fragment stage.
VK_SHADER_STAGE_COMPUTE_BIT specifies the compute stage.
VK_SHADER_STAGE_ALL_GRAPHICS is a combination of bits used as shorthand to specify all graphics stages defined above (excluding the compute stage).
VK_SHADER_STAGE_ALL is a combination of bits used as shorthand to specify all shader stages supported by the device, including all additional stages which are introduced by extensions.
VK_SHADER_STAGE_TASK_BIT_NV specifies the task stage.
VK_SHADER_STAGE_MESH_BIT_NV specifies the mesh stage.
VK_SHADER_STAGE_RAYGEN_BIT_NV specifies the ray generation stage.
VK_SHADER_STAGE_ANY_HIT_BIT_NV specifies the any-hit stage.
VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV specifies the closest hit stage.
VK_SHADER_STAGE_MISS_BIT_NV specifies the miss stage.
VK_SHADER_STAGE_INTERSECTION_BIT_NV specifies the intersection stage.
VK_SHADER_STAGE_CALLABLE_BIT_NV specifies the callable stage.

Note

VK_SHADER_STAGE_ALL_GRAPHICS only includes the original five graphics stages included in Vulkan 1.0, and not any stages added by extensions. Thus, it may not have the desired effect in all cases.

typedef VkFlags VkShaderStageFlags;

VkShaderStageFlags is a bitmask type for setting a mask of zero or more VkShaderStageFlagBits.

The VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure is defined as:

typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           requiredSubgroupSize;
} VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
requiredSubgroupSize is an unsigned integer value that specifies the required subgroup size for the newly created pipeline shader stage.

Valid Usage

VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02760
requiredSubgroupSize must be a power-of-two integer.
VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02761
requiredSubgroupSize must be greater or equal to minSubgroupSize.
VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02762
requiredSubgroupSize must be less than or equal to maxSubgroupSize.

If a VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure is included in the pNext chain of VkPipelineShaderStageCreateInfo, it specifies that the pipeline shader stage being compiled has a required subgroup size.

Valid Usage (Implicit)

VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT

9.2. Graphics Pipelines

Graphics pipelines consist of multiple shader stages, multiple fixed-function pipeline stages, and a pipeline layout.

To create graphics pipelines, call:

VkResult vkCreateGraphicsPipelines(
    VkDevice                                    device,
    VkPipelineCache                             pipelineCache,
    uint32_t                                    createInfoCount,
    const VkGraphicsPipelineCreateInfo*         pCreateInfos,
    const VkAllocationCallbacks*                pAllocator,
    VkPipeline*                                 pPipelines);

device is the logical device that creates the graphics pipelines.
pipelineCache is either VK_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.
createInfoCount is the length of the pCreateInfos and pPipelines arrays.
pCreateInfos is a pointer to an array of VkGraphicsPipelineCreateInfo structures.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pPipelines is a pointer to an array of VkPipeline handles in which the resulting graphics pipeline objects are returned.

The VkGraphicsPipelineCreateInfo structure includes an array of shader create info structures containing all the desired active shader stages, as well as creation info to define all relevant fixed-function stages, and a pipeline layout.

Valid Usage

VUID-vkCreateGraphicsPipelines-flags-00720
If the flags member of any element of pCreateInfos contains the VK_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
VUID-vkCreateGraphicsPipelines-flags-00721
If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set

Valid Usage (Implicit)

VUID-vkCreateGraphicsPipelines-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateGraphicsPipelines-pipelineCache-parameter
If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle
VUID-vkCreateGraphicsPipelines-pCreateInfos-parameter
pCreateInfos must be a valid pointer to an array of createInfoCount valid VkGraphicsPipelineCreateInfo structures
VUID-vkCreateGraphicsPipelines-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateGraphicsPipelines-pPipelines-parameter
pPipelines must be a valid pointer to an array of createInfoCount VkPipeline handles
VUID-vkCreateGraphicsPipelines-createInfoCount-arraylength
createInfoCount must be greater than 0
VUID-vkCreateGraphicsPipelines-pipelineCache-parent
If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INVALID_SHADER_NV

The VkGraphicsPipelineCreateInfo structure is defined as:

typedef struct VkGraphicsPipelineCreateInfo {
    VkStructureType                                  sType;
    const void*                                      pNext;
    VkPipelineCreateFlags                            flags;
    uint32_t                                         stageCount;
    const VkPipelineShaderStageCreateInfo*           pStages;
    const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
    const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
    const VkPipelineTessellationStateCreateInfo*     pTessellationState;
    const VkPipelineViewportStateCreateInfo*         pViewportState;
    const VkPipelineRasterizationStateCreateInfo*    pRasterizationState;
    const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
    const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
    const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
    const VkPipelineDynamicStateCreateInfo*          pDynamicState;
    VkPipelineLayout                                 layout;
    VkRenderPass                                     renderPass;
    uint32_t                                         subpass;
    VkPipeline                                       basePipelineHandle;
    int32_t                                          basePipelineIndex;
} VkGraphicsPipelineCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkPipelineCreateFlagBits specifying how the pipeline will be generated.
stageCount is the number of entries in the pStages array.
pStages is a pointer to an array of stageCount VkPipelineShaderStageCreateInfo structures describing the set of the shader stages to be included in the graphics pipeline.
pVertexInputState is a pointer to a VkPipelineVertexInputStateCreateInfo structure. It is ignored if the pipeline includes a mesh shader stage.
pInputAssemblyState is a pointer to a VkPipelineInputAssemblyStateCreateInfo structure which determines input assembly behavior, as described in Drawing Commands. It is ignored if the pipeline includes a mesh shader stage.
pTessellationState is a pointer to a VkPipelineTessellationStateCreateInfo structure, and is ignored if the pipeline does not include a tessellation control shader stage and tessellation evaluation shader stage.
pViewportState is a pointer to a VkPipelineViewportStateCreateInfo structure, and is ignored if the pipeline has rasterization disabled.
pRasterizationState is a pointer to a VkPipelineRasterizationStateCreateInfo structure.
pMultisampleState is a pointer to a VkPipelineMultisampleStateCreateInfo structure, and is ignored if the pipeline has rasterization disabled.
pDepthStencilState is a pointer to a VkPipelineDepthStencilStateCreateInfo structure, and is ignored if the pipeline has rasterization disabled or if the subpass of the render pass the pipeline is created against does not use a depth/stencil attachment.
pColorBlendState is a pointer to a VkPipelineColorBlendStateCreateInfo structure, and is ignored if the pipeline has rasterization disabled or if the subpass of the render pass the pipeline is created against does not use any color attachments.
pDynamicState is a pointer to a VkPipelineDynamicStateCreateInfo structure, and is used to indicate which properties of the pipeline state object are dynamic and can be changed independently of the pipeline state. This can be NULL, which means no state in the pipeline is considered dynamic.
layout is the description of binding locations used by both the pipeline and descriptor sets used with the pipeline.
renderPass is a handle to a render pass object describing the environment in which the pipeline will be used; the pipeline must only be used with an instance of any render pass compatible with the one provided. See Render Pass Compatibility for more information.
subpass is the index of the subpass in the render pass where this pipeline will be used.
basePipelineHandle is a pipeline to derive from.
basePipelineIndex is an index into the pCreateInfos parameter to use as a pipeline to derive from.

The parameters basePipelineHandle and basePipelineIndex are described in more detail in Pipeline Derivatives.

If any shader stage fails to compile, the compile log will be reported back to the application, and VK_ERROR_INVALID_SHADER_NV will be generated.

Valid Usage

VUID-VkGraphicsPipelineCreateInfo-flags-00722
If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a graphics VkPipeline
VUID-VkGraphicsPipelineCreateInfo-flags-00723
If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command’s pCreateInfos parameter
VUID-VkGraphicsPipelineCreateInfo-flags-00724
If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE
VUID-VkGraphicsPipelineCreateInfo-flags-00725
If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1
VUID-VkGraphicsPipelineCreateInfo-stage-00726
The stage member of each element of pStages must be unique
VUID-VkGraphicsPipelineCreateInfo-pStages-02095
The geometric shader stages provided in pStages must be either from the mesh shading pipeline (stage is VK_SHADER_STAGE_TASK_BIT_NV or VK_SHADER_STAGE_MESH_BIT_NV) or from the primitive shading pipeline (stage is VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, or VK_SHADER_STAGE_GEOMETRY_BIT).
VUID-VkGraphicsPipelineCreateInfo-stage-02096
The stage member of one element of pStages must be either VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_NV.
VUID-VkGraphicsPipelineCreateInfo-stage-00728
The stage member of each element of pStages must not be VK_SHADER_STAGE_COMPUTE_BIT
VUID-VkGraphicsPipelineCreateInfo-pStages-00729
If pStages includes a tessellation control shader stage, it must include a tessellation evaluation shader stage
VUID-VkGraphicsPipelineCreateInfo-pStages-00730
If pStages includes a tessellation evaluation shader stage, it must include a tessellation control shader stage
VUID-VkGraphicsPipelineCreateInfo-pStages-00731
If pStages includes a tessellation control shader stage and a tessellation evaluation shader stage, pTessellationState must be a valid pointer to a valid VkPipelineTessellationStateCreateInfo structure
VUID-VkGraphicsPipelineCreateInfo-pStages-00732
If pStages includes tessellation shader stages, the shader code of at least one stage must contain an OpExecutionMode instruction that specifies the type of subdivision in the pipeline
VUID-VkGraphicsPipelineCreateInfo-pStages-00733
If pStages includes tessellation shader stages, and the shader code of both stages contain an OpExecutionMode instruction that specifies the type of subdivision in the pipeline, they must both specify the same subdivision mode
VUID-VkGraphicsPipelineCreateInfo-pStages-00734
If pStages includes tessellation shader stages, the shader code of at least one stage must contain an OpExecutionMode instruction that specifies the output patch size in the pipeline
VUID-VkGraphicsPipelineCreateInfo-pStages-00735
If pStages includes tessellation shader stages, and the shader code of both contain an OpExecutionMode instruction that specifies the out patch size in the pipeline, they must both specify the same patch size
VUID-VkGraphicsPipelineCreateInfo-pStages-00736
If pStages includes tessellation shader stages, the topology member of pInputAssembly must be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST
VUID-VkGraphicsPipelineCreateInfo-topology-00737
If the topology member of pInputAssembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, pStages must include tessellation shader stages
VUID-VkGraphicsPipelineCreateInfo-pStages-00738
If pStages includes a geometry shader stage, and does not include any tessellation shader stages, its shader code must contain an OpExecutionMode instruction that specifies an input primitive type that is compatible with the primitive topology specified in pInputAssembly
VUID-VkGraphicsPipelineCreateInfo-pStages-00739
If pStages includes a geometry shader stage, and also includes tessellation shader stages, its shader code must contain an OpExecutionMode instruction that specifies an input primitive type that is compatible with the primitive topology that is output by the tessellation stages
VUID-VkGraphicsPipelineCreateInfo-pStages-00740
If pStages includes a fragment shader stage and a geometry shader stage, and the fragment shader code reads from an input variable that is decorated with PrimitiveID, then the geometry shader code must write to a matching output variable, decorated with PrimitiveID, in all execution paths
VUID-VkGraphicsPipelineCreateInfo-pStages-00741
If pStages includes a fragment shader stage, its shader code must not read from any input attachment that is defined as VK_ATTACHMENT_UNUSED in subpass
VUID-VkGraphicsPipelineCreateInfo-pStages-00742
The shader code for the entry points identified by pStages, and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter
VUID-VkGraphicsPipelineCreateInfo-subpass-01756
If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL in the VkAttachmentReference defined by subpass, the depthWriteEnable member of pDepthStencilState must be VK_FALSE
VUID-VkGraphicsPipelineCreateInfo-subpass-01757
If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL in the VkAttachmentReference defined by subpass, the failOp, passOp and depthFailOp members of each of the front and back members of pDepthStencilState must be VK_STENCIL_OP_KEEP
VUID-VkGraphicsPipelineCreateInfo-blendEnable-02023
If rasterization is not disabled and the subpass uses color attachments, then for each color attachment in the subpass the blendEnable member of the corresponding element of the pAttachment member of pColorBlendState must be VK_FALSE if the attached image’s format features does not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT.
VUID-VkGraphicsPipelineCreateInfo-attachmentCount-00746
If rasterization is not disabled and the subpass uses color attachments, the attachmentCount member of pColorBlendState must be equal to the colorAttachmentCount used to create subpass
VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00747
If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT, the pViewports member of pViewportState must be a valid pointer to an array of pViewportState->viewportCount valid VkViewport structures
VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00748
If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SCISSOR, the pScissors member of pViewportState must be a valid pointer to an array of pViewportState->scissorCount VkRect2D structures
VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00749
If the wide lines feature is not enabled, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_LINE_WIDTH, the lineWidth member of pRasterizationState must be 1.0
VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00750
If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, pViewportState must be a valid pointer to a valid VkPipelineViewportStateCreateInfo structure
VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00751
If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, pMultisampleState must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure
VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00752
If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, and subpass uses a depth/stencil attachment, pDepthStencilState must be a valid pointer to a valid VkPipelineDepthStencilStateCreateInfo structure
VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00753
If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, and subpass uses color attachments, pColorBlendState must be a valid pointer to a valid VkPipelineColorBlendStateCreateInfo structure
VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00754
If the depth bias clamping feature is not enabled, no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BIAS, and the depthBiasEnable member of pRasterizationState is VK_TRUE, the depthBiasClamp member of pRasterizationState must be 0.0
VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-02510
If the VK_EXT_depth_range_unrestricted extension is not enabled and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BOUNDS, and the depthBoundsTestEnable member of pDepthStencilState is VK_TRUE, the minDepthBounds and maxDepthBounds members of pDepthStencilState must be between 0.0 and 1.0, inclusive
VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01521
If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure included in the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationGridSize.width must evenly divide VkMultisamplePropertiesEXT::sampleLocationGridSize.width as returned by vkGetPhysicalDeviceMultisamplePropertiesEXT with a samples parameter equaling rasterizationSamples
VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01522
If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure included in the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationGridSize.height must evenly divide VkMultisamplePropertiesEXT::sampleLocationGridSize.height as returned by vkGetPhysicalDeviceMultisamplePropertiesEXT with a samples parameter equaling rasterizationSamples
VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01523
If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure included in the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples
VUID-VkGraphicsPipelineCreateInfo-sampleLocationsEnable-01524
If the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure included in the pNext chain of pMultisampleState is VK_TRUE, the fragment shader code must not statically use the extended instruction InterpolateAtSample
VUID-VkGraphicsPipelineCreateInfo-layout-00756
layout must be consistent with all shaders specified in pStages
VUID-VkGraphicsPipelineCreateInfo-subpass-00757
If neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, and if subpass uses color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must be the same as the sample count for those subpass attachments
VUID-VkGraphicsPipelineCreateInfo-subpass-01505
If the VK_AMD_mixed_attachment_samples extension is enabled, and if subpass uses color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must equal the maximum of the sample counts of those subpass attachments
VUID-VkGraphicsPipelineCreateInfo-subpass-01411
If the VK_NV_framebuffer_mixed_samples extension is enabled, and if subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled, then the rasterizationSamples member of pMultisampleState must be the same as the sample count of the depth/stencil attachment
VUID-VkGraphicsPipelineCreateInfo-subpass-01412
If the VK_NV_framebuffer_mixed_samples extension is enabled, and if subpass has any color attachments, then the rasterizationSamples member of pMultisampleState must be greater than or equal to the sample count for those subpass attachments
VUID-VkGraphicsPipelineCreateInfo-coverageReductionMode-02722
If the VK_NV_coverage_reduction_mode extension is enabled, the coverage reduction mode specified by VkPipelineCoverageReductionStateCreateInfoNV::coverageReductionMode, the rasterizationSamples member of pMultisampleState and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV
VUID-VkGraphicsPipelineCreateInfo-subpass-00758
If subpass does not use any color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must follow the rules for a zero-attachment subpass
VUID-VkGraphicsPipelineCreateInfo-subpass-00759
subpass must be a valid subpass within renderPass
VUID-VkGraphicsPipelineCreateInfo-renderPass-00760
If the renderPass has multiview enabled and subpass has more than one bit set in the view mask and multiviewTessellationShader is not enabled, then pStages must not include tessellation shaders.
VUID-VkGraphicsPipelineCreateInfo-renderPass-00761
If the renderPass has multiview enabled and subpass has more than one bit set in the view mask and multiviewGeometryShader is not enabled, then pStages must not include a geometry shader.
VUID-VkGraphicsPipelineCreateInfo-renderPass-00762
If the renderPass has multiview enabled and subpass has more than one bit set in the view mask, shaders in the pipeline must not write to the Layer built-in output
VUID-VkGraphicsPipelineCreateInfo-renderPass-00763
If the renderPass has multiview enabled, then all shaders must not include variables decorated with the Layer built-in decoration in their interfaces.
VUID-VkGraphicsPipelineCreateInfo-flags-00764
flags must not contain the VK_PIPELINE_CREATE_DISPATCH_BASE flag.
VUID-VkGraphicsPipelineCreateInfo-pStages-01565
If pStages includes a fragment shader stage and an input attachment was referenced by the VkRenderPassInputAttachmentAspectCreateInfo at renderPass create time, its shader code must not read from any aspect that was not specified in the aspectMask of the corresponding VkInputAttachmentAspectReference structure.
VUID-VkGraphicsPipelineCreateInfo-layout-01688
The number of resources in layout accessible to each shader stage that is used by the pipeline must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources
VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01715
If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, and the viewportWScalingEnable member of a VkPipelineViewportWScalingStateCreateInfoNV structure, included in the pNext chain of pViewportState, is VK_TRUE, the pViewportWScalings member of the VkPipelineViewportWScalingStateCreateInfoNV must be a pointer to an array of VkPipelineViewportWScalingStateCreateInfoNV::viewportCount valid VkViewportWScalingNV structures
VUID-VkGraphicsPipelineCreateInfo-pStages-02097
If pStages includes a vertex shader stage, pVertexInputState must be a valid pointer to a valid VkPipelineVertexInputStateCreateInfo structure
VUID-VkGraphicsPipelineCreateInfo-pStages-02098
If pStages includes a vertex shader stage, pInputAssemblyState must be a valid pointer to a valid VkPipelineInputAssemblyStateCreateInfo structure
VUID-VkGraphicsPipelineCreateInfo-pStages-02317
The Xfb execution mode can be specified by only one shader stage in pStages
VUID-VkGraphicsPipelineCreateInfo-pStages-02318
If any shader stage in pStages specifies Xfb execution mode it must be the last vertex processing stage
VUID-VkGraphicsPipelineCreateInfo-rasterizationStream-02319
If a VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream value other than zero is specified, all variables in the output interface of the entry point being compiled decorated with Position, PointSize, ClipDistance, or CullDistance must all be decorated with identical Stream values that match the rasterizationStream
VUID-VkGraphicsPipelineCreateInfo-rasterizationStream-02320
If VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream is zero, or not specified, all variables in the output interface of the entry point being compiled decorated with Position, PointSize, ClipDistance, or CullDistance must all be decorated with a Stream value of zero, or must not specify the Stream decoration
VUID-VkGraphicsPipelineCreateInfo-geometryStreams-02321
If the last vertex processing stage is a geometry shader, and that geometry shader uses the GeometryStreams capability, then VkPhysicalDeviceTransformFeedbackFeaturesEXT::geometryStreams feature must be enabled
VUID-VkGraphicsPipelineCreateInfo-None-02322
If there are any mesh shader stages in the pipeline there must not be any shader stage in the pipeline with a Xfb execution mode.
VUID-VkGraphicsPipelineCreateInfo-lineRasterizationMode-02766
If the lineRasterizationMode member of a VkPipelineRasterizationLineStateCreateInfoEXT structure included in the pNext chain of pRasterizationState is VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT or VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT and if rasterization is enabled, then the alphaToCoverageEnable, alphaToOneEnable, and sampleShadingEnable members of pMultisampleState must all be VK_FALSE
VUID-VkGraphicsPipelineCreateInfo-stippledLineEnable-02767
If the stippledLineEnable member of VkPipelineRasterizationLineStateCreateInfoEXT is VK_TRUE and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_LINE_STIPPLE_EXT, then the lineStippleFactor member of VkPipelineRasterizationLineStateCreateInfoEXT must be in the range [1,256]

Valid Usage (Implicit)

VUID-VkGraphicsPipelineCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
VUID-VkGraphicsPipelineCreateInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineCompilerControlCreateInfoAMD, VkPipelineCreationFeedbackCreateInfoEXT, VkPipelineDiscardRectangleStateCreateInfoEXT, or VkPipelineRepresentativeFragmentTestStateCreateInfoNV
VUID-VkGraphicsPipelineCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkGraphicsPipelineCreateInfo-flags-parameter
flags must be a valid combination of VkPipelineCreateFlagBits values
VUID-VkGraphicsPipelineCreateInfo-pStages-parameter
pStages must be a valid pointer to an array of stageCount valid VkPipelineShaderStageCreateInfo structures
VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-parameter
pRasterizationState must be a valid pointer to a valid VkPipelineRasterizationStateCreateInfo structure
VUID-VkGraphicsPipelineCreateInfo-pDynamicState-parameter
If pDynamicState is not NULL, pDynamicState must be a valid pointer to a valid VkPipelineDynamicStateCreateInfo structure
VUID-VkGraphicsPipelineCreateInfo-layout-parameter
layout must be a valid VkPipelineLayout handle
VUID-VkGraphicsPipelineCreateInfo-renderPass-parameter
renderPass must be a valid VkRenderPass handle
VUID-VkGraphicsPipelineCreateInfo-stageCount-arraylength
stageCount must be greater than 0
VUID-VkGraphicsPipelineCreateInfo-commonparent
Each of basePipelineHandle, layout, and renderPass that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

Possible values of the flags member of VkGraphicsPipelineCreateInfo, VkComputePipelineCreateInfo, and VkRayTracingPipelineCreateInfoNV, specifying how a pipeline is created, are:

typedef enum VkPipelineCreateFlagBits {
    VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
    VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
    VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
    VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
    VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010,
    VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,
    VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040,
    VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080,
    VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
    VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
    VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
    VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkPipelineCreateFlagBits;

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.
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 vkCreateGraphicsPipelines or vkCreateComputePipelines.
VK_PIPELINE_CREATE_DERIVATIVE_BIT specifies that the pipeline to be created will be a child of a previously created parent pipeline.
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT specifies that any shader input variables decorated as ViewIndex will be assigned values as if they were decorated as DeviceIndex.
VK_PIPELINE_CREATE_DISPATCH_BASE specifies that a compute pipeline can be used with vkCmdDispatchBase with a non-zero base workgroup.
VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV specifies that a pipeline is created with all shaders in the deferred state. Before using the pipeline the application must call vkCompileDeferredNV exactly once on each shader in the pipeline before using the pipeline.
VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR specifies that the shader compiler should capture statistics for the executables produced by the compile process which can later be retrieved by calling vkGetPipelineExecutableStatisticsKHR. Enabling this flag must not affect the final compiled pipeline but may disable pipeline caching or otherwise affect pipeline creation time.
VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR specifies that the shader compiler should capture the internal representations of executables produced by the compile process which can later be retrieved by calling vkGetPipelineExecutableInternalRepresentationsKHR. Enabling this flag must not affect the final compiled pipeline but may disable pipeline caching or otherwise affect pipeline creation time.

It is valid to set both VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT and VK_PIPELINE_CREATE_DERIVATIVE_BIT. This allows a pipeline to be both a parent and possibly a child in a pipeline hierarchy. See Pipeline Derivatives for more information.

typedef VkFlags VkPipelineCreateFlags;

VkPipelineCreateFlags is a bitmask type for setting a mask of zero or more VkPipelineCreateFlagBits.

The VkPipelineDynamicStateCreateInfo structure is defined as:

typedef struct VkPipelineDynamicStateCreateInfo {
    VkStructureType                      sType;
    const void*                          pNext;
    VkPipelineDynamicStateCreateFlags    flags;
    uint32_t                             dynamicStateCount;
    const VkDynamicState*                pDynamicStates;
} VkPipelineDynamicStateCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
dynamicStateCount is the number of elements in the pDynamicStates array.
pDynamicStates is a pointer to an array of VkDynamicState values specifying which pieces of pipeline state will use the values from dynamic state commands rather than from pipeline state creation info.

Valid Usage

VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-01442
Each element of pDynamicStates must be unique

Valid Usage (Implicit)

VUID-VkPipelineDynamicStateCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO
VUID-VkPipelineDynamicStateCreateInfo-pNext-pNext
pNext must be NULL
VUID-VkPipelineDynamicStateCreateInfo-flags-zerobitmask
flags must be 0
VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-parameter
If dynamicStateCount is not 0, pDynamicStates must be a valid pointer to an array of dynamicStateCount valid VkDynamicState values

typedef VkFlags VkPipelineDynamicStateCreateFlags;

VkPipelineDynamicStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

The source of different pieces of dynamic state is specified by the VkPipelineDynamicStateCreateInfo::pDynamicStates property of the currently active pipeline, each of whose elements must be one of the values:

typedef enum VkDynamicState {
    VK_DYNAMIC_STATE_VIEWPORT = 0,
    VK_DYNAMIC_STATE_SCISSOR = 1,
    VK_DYNAMIC_STATE_LINE_WIDTH = 2,
    VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
    VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
    VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
    VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
    VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
    VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
    VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000,
    VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000,
    VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000,
    VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004,
    VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006,
    VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001,
    VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000,
    VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
} VkDynamicState;

VK_DYNAMIC_STATE_VIEWPORT specifies that the pViewports state in VkPipelineViewportStateCreateInfo will be ignored and must be set dynamically with vkCmdSetViewport before any draw commands. The number of viewports used by a pipeline is still specified by the viewportCount member of VkPipelineViewportStateCreateInfo.
VK_DYNAMIC_STATE_SCISSOR specifies that the pScissors state in VkPipelineViewportStateCreateInfo will be ignored and must be set dynamically with vkCmdSetScissor before any draw commands. The number of scissor rectangles used by a pipeline is still specified by the scissorCount member of VkPipelineViewportStateCreateInfo.
VK_DYNAMIC_STATE_LINE_WIDTH specifies that the lineWidth state in VkPipelineRasterizationStateCreateInfo will be ignored and must be set dynamically with vkCmdSetLineWidth before any draw commands that generate line primitives for the rasterizer.
VK_DYNAMIC_STATE_DEPTH_BIAS specifies that the depthBiasConstantFactor, depthBiasClamp and depthBiasSlopeFactor states in VkPipelineRasterizationStateCreateInfo will be ignored and must be set dynamically with vkCmdSetDepthBias before any draws are performed with depthBiasEnable in VkPipelineRasterizationStateCreateInfo set to VK_TRUE.
VK_DYNAMIC_STATE_BLEND_CONSTANTS specifies that the blendConstants state in VkPipelineColorBlendStateCreateInfo will be ignored and must be set dynamically with vkCmdSetBlendConstants before any draws are performed with a pipeline state with VkPipelineColorBlendAttachmentState member blendEnable set to VK_TRUE and any of the blend functions using a constant blend color.
VK_DYNAMIC_STATE_DEPTH_BOUNDS specifies that the minDepthBounds and maxDepthBounds states of VkPipelineDepthStencilStateCreateInfo will be ignored and must be set dynamically with vkCmdSetDepthBounds before any draws are performed with a pipeline state with VkPipelineDepthStencilStateCreateInfo member depthBoundsTestEnable set to VK_TRUE.
VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK specifies that the compareMask state in VkPipelineDepthStencilStateCreateInfo for both front and back will be ignored and must be set dynamically with vkCmdSetStencilCompareMask before any draws are performed with a pipeline state with VkPipelineDepthStencilStateCreateInfo member stencilTestEnable set to VK_TRUE
VK_DYNAMIC_STATE_STENCIL_WRITE_MASK specifies that the writeMask state in VkPipelineDepthStencilStateCreateInfo for both front and back will be ignored and must be set dynamically with vkCmdSetStencilWriteMask before any draws are performed with a pipeline state with VkPipelineDepthStencilStateCreateInfo member stencilTestEnable set to VK_TRUE
VK_DYNAMIC_STATE_STENCIL_REFERENCE specifies that the reference state in VkPipelineDepthStencilStateCreateInfo for both front and back will be ignored and must be set dynamically with vkCmdSetStencilReference before any draws are performed with a pipeline state with VkPipelineDepthStencilStateCreateInfo member stencilTestEnable set to VK_TRUE
VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV specifies that the pViewportScalings state in VkPipelineViewportWScalingStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetViewportWScalingNV before any draws are performed with a pipeline state with VkPipelineViewportWScalingStateCreateInfoNV member viewportScalingEnable set to VK_TRUE
VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT specifies that the pDiscardRectangles state in VkPipelineDiscardRectangleStateCreateInfoEXT will be ignored and must be set dynamically with vkCmdSetDiscardRectangleEXT before any draw or clear commands. The VkDiscardRectangleModeEXT and the number of active discard rectangles is still specified by the discardRectangleMode and discardRectangleCount members of VkPipelineDiscardRectangleStateCreateInfoEXT.
VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT specifies that the sampleLocationsInfo state in VkPipelineSampleLocationsStateCreateInfoEXT will be ignored and must be set dynamically with vkCmdSetSampleLocationsEXT before any draw or clear commands. Enabling custom sample locations is still indicated by the sampleLocationsEnable member of VkPipelineSampleLocationsStateCreateInfoEXT.
VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV specifies that the pExclusiveScissors state in VkPipelineViewportExclusiveScissorStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetExclusiveScissorNV before any draw commands. The number of exclusive scissor rectangles used by a pipeline is still specified by the exclusiveScissorCount member of VkPipelineViewportExclusiveScissorStateCreateInfoNV.
VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV specifies that the pShadingRatePalettes state in VkPipelineViewportShadingRateImageStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetViewportShadingRatePaletteNV before any draw commands.
VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV specifies that the coarse sample order state in VkPipelineViewportCoarseSampleOrderStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetCoarseSampleOrderNV before any draw commands.
VK_DYNAMIC_STATE_LINE_STIPPLE_EXT specifies that the lineStippleFactor and lineStipplePattern state in VkPipelineRasterizationLineStateCreateInfoEXT will be ignored and must be set dynamically with vkCmdSetLineStippleEXT before any draws are performed with a pipeline state with VkPipelineRasterizationLineStateCreateInfoEXT member stippledLineEnable set to VK_TRUE.

9.2.1. Valid Combinations of Stages for Graphics Pipelines

The geometric primitive processing can either be handled on a per primitive basis by the vertex, tessellation, and geometry shader stages, or on a per mesh basis using task and mesh shader stages. If the pipeline includes a mesh shader stage, it uses the mesh pipeline, otherwise it uses the primitive pipeline.

If a task shader is omitted, the task shading stage is skipped.

If tessellation shader stages are omitted, the tessellation shading and fixed-function stages of the pipeline are skipped.

If a geometry shader is omitted, the geometry shading stage is skipped.

If a fragment shader is omitted, fragment color outputs have undefined values, and the fragment depth value is unmodified. This can be useful for depth-only rendering.

Presence of a shader stage in a pipeline is indicated by including a valid VkPipelineShaderStageCreateInfo with module and pName selecting an entry point from a shader module, where that entry point is valid for the stage specified by stage.

Presence of some of the fixed-function stages in the pipeline is implicitly derived from enabled shaders and provided state. For example, the fixed-function tessellator is always present when the pipeline has valid Tessellation Control and Tessellation Evaluation shaders.

For example:

Depth/stencil-only rendering in a subpass with no color attachments
- Active Pipeline Shader Stages
  - Vertex Shader
- Required: Fixed-Function Pipeline Stages
Color-only rendering in a subpass with no depth/stencil attachment
- Active Pipeline Shader Stages
  - Vertex Shader
  - Fragment Shader
- Required: Fixed-Function Pipeline Stages
Rendering pipeline with tessellation and geometry shaders
- Active Pipeline Shader Stages
  - Vertex Shader
  - Tessellation Control Shader
  - Tessellation Evaluation Shader
  - Geometry Shader
  - Fragment Shader
- Required: Fixed-Function Pipeline Stages
Rendering pipeline with task and mesh shaders
- Active Pipeline Shader Stages
  - Task Shader
  - Mesh Shader
  - Fragment Shader
- Required: Fixed-Function Pipeline Stages

9.3. Pipeline destruction

To destroy a graphics or compute pipeline, call:

void vkDestroyPipeline(
    VkDevice                                    device,
    VkPipeline                                  pipeline,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the pipeline.
pipeline is the handle of the pipeline to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyPipeline-pipeline-00765
All submitted commands that refer to pipeline must have completed execution
VUID-vkDestroyPipeline-pipeline-00766
If VkAllocationCallbacks were provided when pipeline was created, a compatible set of callbacks must be provided here
VUID-vkDestroyPipeline-pipeline-00767
If no VkAllocationCallbacks were provided when pipeline was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyPipeline-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyPipeline-pipeline-parameter
If pipeline is not VK_NULL_HANDLE, pipeline must be a valid VkPipeline handle
VUID-vkDestroyPipeline-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyPipeline-pipeline-parent
If pipeline is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to pipeline must be externally synchronized

9.4. Multiple Pipeline Creation

Multiple pipelines can be created simultaneously by passing an array of VkGraphicsPipelineCreateInfo or VkComputePipelineCreateInfo structures into the vkCreateGraphicsPipelines and vkCreateComputePipelines commands, respectively. Applications can group together similar pipelines to be created in a single call, and implementations are encouraged to look for reuse opportunities within a group-create.

When an application attempts to create many pipelines in a single command, it is possible that some subset may fail creation. In that case, the corresponding entries in the pPipelines output array will be filled with VK_NULL_HANDLE values. If any pipeline fails creation (for example, due to out of memory errors), the vkCreate*Pipelines commands will return an error code. The implementation will attempt to create all pipelines, and only return VK_NULL_HANDLE values for those that actually failed.

9.5. Pipeline Derivatives

A pipeline derivative is a child pipeline created from a parent pipeline, where the child and parent are expected to have much commonality. The goal of derivative pipelines is that they be cheaper to create using the parent as a starting point, and that it be more efficient (on either host or device) to switch/bind between children of the same parent.

A derivative pipeline is created by setting the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag in the Vk*PipelineCreateInfo structure. If this is set, then exactly one of basePipelineHandle or basePipelineIndex members of the structure must have a valid handle/index, and specifies the parent pipeline. If basePipelineHandle is used, the parent pipeline must have already been created. If basePipelineIndex is used, then the parent is being created in the same command. VK_NULL_HANDLE acts as the invalid handle for basePipelineHandle, and -1 is the invalid index for basePipelineIndex. If basePipelineIndex is used, the base pipeline must appear earlier in the array. The base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set.

9.6. Pipeline Cache

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.

Pipeline cache objects are represented by VkPipelineCache handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)

To create pipeline cache objects, call:

VkResult vkCreatePipelineCache(
    VkDevice                                    device,
    const VkPipelineCacheCreateInfo*            pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkPipelineCache*                            pPipelineCache);

device is the logical device that creates the pipeline cache object.
pCreateInfo is a pointer to a VkPipelineCacheCreateInfo structure containing initial parameters for the pipeline cache object.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pPipelineCache is a pointer to a VkPipelineCache handle in which the resulting pipeline cache object is returned.

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 vkGetPipelineCacheData. 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 vkCreateGraphicsPipelines and vkCreateComputePipelines commands. If the pipeline cache passed into these commands is not VK_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

Valid Usage (Implicit)

VUID-vkCreatePipelineCache-device-parameter
device must be a valid VkDevice handle
VUID-vkCreatePipelineCache-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkPipelineCacheCreateInfo structure
VUID-vkCreatePipelineCache-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreatePipelineCache-pPipelineCache-parameter
pPipelineCache must be a valid pointer to a VkPipelineCache handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkPipelineCacheCreateInfo structure is defined as:

typedef struct VkPipelineCacheCreateInfo {
    VkStructureType               sType;
    const void*                   pNext;
    VkPipelineCacheCreateFlags    flags;
    size_t                        initialDataSize;
    const void*                   pInitialData;
} VkPipelineCacheCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
initialDataSize is the number of bytes in pInitialData. If initialDataSize is zero, the pipeline cache will initially be empty.
pInitialData is a pointer to previously retrieved pipeline cache data. If the pipeline cache data is incompatible (as defined below) with the device, the pipeline cache will be initially empty. If initialDataSize is zero, pInitialData is ignored.

Valid Usage

VUID-VkPipelineCacheCreateInfo-initialDataSize-00768
If initialDataSize is not 0, it must be equal to the size of pInitialData, as returned by vkGetPipelineCacheData when pInitialData was originally retrieved
VUID-VkPipelineCacheCreateInfo-initialDataSize-00769
If initialDataSize is not 0, pInitialData must have been retrieved from a previous call to vkGetPipelineCacheData

Valid Usage (Implicit)

VUID-VkPipelineCacheCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO
VUID-VkPipelineCacheCreateInfo-pNext-pNext
pNext must be NULL
VUID-VkPipelineCacheCreateInfo-flags-zerobitmask
flags must be 0
VUID-VkPipelineCacheCreateInfo-pInitialData-parameter
If initialDataSize is not 0, pInitialData must be a valid pointer to an array of initialDataSize bytes

typedef VkFlags VkPipelineCacheCreateFlags;

VkPipelineCacheCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

Pipeline cache objects can be merged using the command:

VkResult vkMergePipelineCaches(
    VkDevice                                    device,
    VkPipelineCache                             dstCache,
    uint32_t                                    srcCacheCount,
    const VkPipelineCache*                      pSrcCaches);

device is the logical device that owns the pipeline cache objects.
dstCache is the handle of the pipeline cache to merge results into.
srcCacheCount is the length of the pSrcCaches array.
pSrcCaches is a pointer to an array of pipeline cache handles, which will be merged into dstCache. The previous contents of dstCache are included after the merge.

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

VUID-vkMergePipelineCaches-dstCache-00770
dstCache must not appear in the list of source caches

Valid Usage (Implicit)

VUID-vkMergePipelineCaches-device-parameter
device must be a valid VkDevice handle
VUID-vkMergePipelineCaches-dstCache-parameter
dstCache must be a valid VkPipelineCache handle
VUID-vkMergePipelineCaches-pSrcCaches-parameter
pSrcCaches must be a valid pointer to an array of srcCacheCount valid VkPipelineCache handles
VUID-vkMergePipelineCaches-srcCacheCount-arraylength
srcCacheCount must be greater than 0
VUID-vkMergePipelineCaches-dstCache-parent
dstCache must have been created, allocated, or retrieved from device
VUID-vkMergePipelineCaches-pSrcCaches-parent
Each element of pSrcCaches must have been created, allocated, or retrieved from device

Host Synchronization

Host access to dstCache must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Data can be retrieved from a pipeline cache object using the command:

VkResult vkGetPipelineCacheData(
    VkDevice                                    device,
    VkPipelineCache                             pipelineCache,
    size_t*                                     pDataSize,
    void*                                       pData);

device is the logical device that owns the pipeline cache.
pipelineCache is the pipeline cache to retrieve data from.
pDataSize is a pointer to a size_t value related to the amount of data in the pipeline cache, as described below.
pData is either NULL or a pointer to a buffer.

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 pDataSize 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 VK_INCOMPLETE. Any data written to pData is valid and can be provided as the pInitialData member of the VkPipelineCacheCreateInfo structure passed to vkCreatePipelineCache.

Two calls to vkGetPipelineCacheData with the same parameters must retrieve the same data unless a command that modifies the contents of the cache is called between them.

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:

Table 12. Layout for pipeline cache header version `VK_PIPELINE_CACHE_HEADER_VERSION_ONE`
Offset	Size	Meaning
0	4	length in bytes of the entire pipeline cache header written as a stream of bytes, with the least significant byte first
4	4	a VkPipelineCacheHeaderVersion value written as a stream of bytes, with the least significant byte first
8	4	a vendor ID equal to `VkPhysicalDeviceProperties`::`vendorID` written as a stream of bytes, with the least significant byte first
12	4	a device ID equal to `VkPhysicalDeviceProperties`::`deviceID` written as a stream of bytes, with the least significant byte first
16	`VK_UUID_SIZE`	a pipeline cache ID equal to `VkPhysicalDeviceProperties`::`pipelineCacheUUID`

The first four bytes encode the length of the entire pipeline cache 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, as described for VkPipelineCacheHeaderVersion. A consumer of the pipeline cache should use the cache version to interpret the remainder of the cache header.

If pDataSize is less than what is necessary to store this header, nothing will be written to pData and zero will be written to pDataSize.

Valid Usage (Implicit)

VUID-vkGetPipelineCacheData-device-parameter
device must be a valid VkDevice handle
VUID-vkGetPipelineCacheData-pipelineCache-parameter
pipelineCache must be a valid VkPipelineCache handle
VUID-vkGetPipelineCacheData-pDataSize-parameter
pDataSize must be a valid pointer to a size_t value
VUID-vkGetPipelineCacheData-pData-parameter
If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of pDataSize bytes
VUID-vkGetPipelineCacheData-pipelineCache-parent
pipelineCache must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Possible values of the second group of four bytes in the header returned by vkGetPipelineCacheData, encoding the pipeline cache version, are:

typedef enum VkPipelineCacheHeaderVersion {
    VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
    VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
} VkPipelineCacheHeaderVersion;

VK_PIPELINE_CACHE_HEADER_VERSION_ONE specifies version one of the pipeline cache.

To destroy a pipeline cache, call:

void vkDestroyPipelineCache(
    VkDevice                                    device,
    VkPipelineCache                             pipelineCache,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the pipeline cache object.
pipelineCache is the handle of the pipeline cache to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyPipelineCache-pipelineCache-00771
If VkAllocationCallbacks were provided when pipelineCache was created, a compatible set of callbacks must be provided here
VUID-vkDestroyPipelineCache-pipelineCache-00772
If no VkAllocationCallbacks were provided when pipelineCache was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyPipelineCache-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyPipelineCache-pipelineCache-parameter
If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle
VUID-vkDestroyPipelineCache-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyPipelineCache-pipelineCache-parent
If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to pipelineCache must be externally synchronized

9.7. Specialization Constants

Specialization constants are a mechanism whereby constants in a SPIR-V module can have their constant value specified at the time the VkPipeline is created. This allows a SPIR-V module to have constants that can be modified while executing an application that uses the Vulkan API.

Note

Specialization constants are useful to allow a compute shader to have its local workgroup size changed at runtime by the user, for example.

Each VkPipelineShaderStageCreateInfo structure contains a pSpecializationInfo member, which can be NULL to indicate no specialization constants, or point to a VkSpecializationInfo structure.

The VkSpecializationInfo structure is defined as:

typedef struct VkSpecializationInfo {
    uint32_t                           mapEntryCount;
    const VkSpecializationMapEntry*    pMapEntries;
    size_t                             dataSize;
    const void*                        pData;
} VkSpecializationInfo;

mapEntryCount is the number of entries in the pMapEntries array.
pMapEntries is a pointer to an array of VkSpecializationMapEntry structures which map constant IDs to offsets in pData.
dataSize is the byte size of the pData buffer.
pData contains the actual constant values to specialize with.

pMapEntries is a pointer to a VkSpecializationMapEntry structure.

Valid Usage

VUID-VkSpecializationInfo-offset-00773
The offset member of each element of pMapEntries must be less than dataSize
VUID-VkSpecializationInfo-pMapEntries-00774
The size member of each element of pMapEntries must be less than or equal to dataSize minus offset

Valid Usage (Implicit)

VUID-VkSpecializationInfo-pMapEntries-parameter
If mapEntryCount is not 0, pMapEntries must be a valid pointer to an array of mapEntryCount valid VkSpecializationMapEntry structures
VUID-VkSpecializationInfo-pData-parameter
If dataSize is not 0, pData must be a valid pointer to an array of dataSize bytes

The VkSpecializationMapEntry structure is defined as:

typedef struct VkSpecializationMapEntry {
    uint32_t    constantID;
    uint32_t    offset;
    size_t      size;
} VkSpecializationMapEntry;

constantID is the ID of the specialization constant in SPIR-V.
offset is the byte offset of the specialization constant value within the supplied data buffer.
size is the byte size of the specialization constant value within the supplied data buffer.

If a constantID value is not a specialization constant ID used in the shader, that map entry does not affect the behavior of the pipeline.

Valid Usage

VUID-VkSpecializationMapEntry-constantID-00776
For a constantID specialization constant declared in a shader, size must match the byte size of the constantID. If the specialization constant is of type boolean, size must be the byte size of VkBool32

In human readable SPIR-V:

OpDecorate %x SpecId 13 ; decorate .x component of WorkgroupSize with ID 13
OpDecorate %y SpecId 42 ; decorate .y component of WorkgroupSize with ID 42
OpDecorate %z SpecId 3  ; decorate .z component of WorkgroupSize with ID 3
OpDecorate %wgsize BuiltIn WorkgroupSize ; decorate WorkgroupSize onto constant
%i32 = OpTypeInt 32 0 ; declare an unsigned 32-bit type
%uvec3 = OpTypeVector %i32 3 ; declare a 3 element vector type of unsigned 32-bit
%x = OpSpecConstant %i32 1 ; declare the .x component of WorkgroupSize
%y = OpSpecConstant %i32 1 ; declare the .y component of WorkgroupSize
%z = OpSpecConstant %i32 1 ; declare the .z component of WorkgroupSize
%wgsize = OpSpecConstantComposite %uvec3 %x %y %z ; declare WorkgroupSize

From the above we have three specialization constants, one for each of the x, y & z elements of the WorkgroupSize vector.

Now to specialize the above via the specialization constants mechanism:

const VkSpecializationMapEntry entries[] =
{
    {
        13,                             // constantID
        0 * sizeof(uint32_t),           // offset
        sizeof(uint32_t)                // size
    },
    {
        42,                             // constantID
        1 * sizeof(uint32_t),           // offset
        sizeof(uint32_t)                // size
    },
    {
        3,                              // constantID
        2 * sizeof(uint32_t),           // offset
        sizeof(uint32_t)                // size
    }
};

const uint32_t data[] = { 16, 8, 4 }; // our workgroup size is 16x8x4

const VkSpecializationInfo info =
{
    3,                                  // mapEntryCount
    entries,                            // pMapEntries
    3 * sizeof(uint32_t),               // dataSize
    data,                               // pData
};

Then when calling vkCreateComputePipelines, and passing the VkSpecializationInfo we defined as the pSpecializationInfo parameter of VkPipelineShaderStageCreateInfo, we will create a compute pipeline with the runtime specified local workgroup size.

Another example would be that an application has a SPIR-V module that has some platform-dependent constants they wish to use.

In human readable SPIR-V:

OpDecorate %1 SpecId 0  ; decorate our signed 32-bit integer constant
OpDecorate %2 SpecId 12 ; decorate our 32-bit floating-point constant
%i32 = OpTypeInt 32 1   ; declare a signed 32-bit type
%float = OpTypeFloat 32 ; declare a 32-bit floating-point type
%1 = OpSpecConstant %i32 -1 ; some signed 32-bit integer constant
%2 = OpSpecConstant %float 0.5 ; some 32-bit floating-point constant

From the above we have two specialization constants, one is a signed 32-bit integer and the second is a 32-bit floating-point.

Now to specialize the above via the specialization constants mechanism:

struct SpecializationData {
    int32_t data0;
    float data1;
};

const VkSpecializationMapEntry entries[] =
{
    {
        0,                                    // constantID
        offsetof(SpecializationData, data0),  // offset
        sizeof(SpecializationData::data0)     // size
    },
    {
        12,                                   // constantID
        offsetof(SpecializationData, data1),  // offset
        sizeof(SpecializationData::data1)     // size
    }
};

SpecializationData data;
data.data0 = -42;    // set the data for the 32-bit integer
data.data1 = 42.0f;  // set the data for the 32-bit floating-point

const VkSpecializationInfo info =
{
    2,                                  // mapEntryCount
    entries,                            // pMapEntries
    sizeof(data),                       // dataSize
    &data,                              // pData
};

It is legal for a SPIR-V module with specializations to be compiled into a pipeline where no specialization info was provided. SPIR-V specialization constants contain default values such that if a specialization is not provided, the default value will be used. In the examples above, it would be valid for an application to only specialize some of the specialization constants within the SPIR-V module, and let the other constants use their default values encoded within the OpSpecConstant declarations.

9.8. Pipeline Binding

Once a pipeline has been created, it can be bound to the command buffer using the command:

void vkCmdBindPipeline(
    VkCommandBuffer                             commandBuffer,
    VkPipelineBindPoint                         pipelineBindPoint,
    VkPipeline                                  pipeline);

commandBuffer is the command buffer that the pipeline will be bound to.
pipelineBindPoint is a VkPipelineBindPoint value specifying whether to bind to the compute or graphics bind point. Binding one does not disturb the other.
pipeline is the pipeline to be bound.

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 VK_PIPELINE_BIND_POINT_COMPUTE controls the behavior of vkCmdDispatch and vkCmdDispatchIndirect. The pipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS controls the behavior of all drawing commands. The pipeline bound to VK_PIPELINE_BIND_POINT_RAY_TRACING_NV controls the behavior of vkCmdTraceRaysNV. No other commands are affected by the pipeline state.

Valid Usage

VUID-vkCmdBindPipeline-pipelineBindPoint-00777
If pipelineBindPoint is VK_PIPELINE_BIND_POINT_COMPUTE, the VkCommandPool that commandBuffer was allocated from must support compute operations
VUID-vkCmdBindPipeline-pipelineBindPoint-00778
If pipelineBindPoint is VK_PIPELINE_BIND_POINT_GRAPHICS, the VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdBindPipeline-pipelineBindPoint-00779
If pipelineBindPoint is VK_PIPELINE_BIND_POINT_COMPUTE, pipeline must be a compute pipeline
VUID-vkCmdBindPipeline-pipelineBindPoint-00780
If pipelineBindPoint is VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline must be a graphics pipeline
VUID-vkCmdBindPipeline-pipeline-00781
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
VUID-vkCmdBindPipeline-variableSampleLocations-01525
If VkPhysicalDeviceSampleLocationsPropertiesEXT::variableSampleLocations is VK_FALSE, and pipeline is a graphics pipeline created with a VkPipelineSampleLocationsStateCreateInfoEXT structure having its sampleLocationsEnable member set to VK_TRUE but without VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT enabled then the current render pass instance must have been begun by specifying a VkRenderPassSampleLocationsBeginInfoEXT structure whose pPostSubpassSampleLocations member contains an element with a subpassIndex matching the current subpass index and the sampleLocationsInfo member of that element must match the sampleLocationsInfo specified in VkPipelineSampleLocationsStateCreateInfoEXT when the pipeline was created
VUID-vkCmdBindPipeline-None-02323
This command must not be recorded when transform feedback is active
VUID-vkCmdBindPipeline-pipelineBindPoint-02391
If pipelineBindPoint is VK_PIPELINE_BIND_POINT_RAY_TRACING_NV, the VkCommandPool that commandBuffer was allocated from must support compute operations
VUID-vkCmdBindPipeline-pipelineBindPoint-02392
If pipelineBindPoint is VK_PIPELINE_BIND_POINT_RAY_TRACING_NV, the pipeline must be a ray tracing pipeline

Valid Usage (Implicit)

VUID-vkCmdBindPipeline-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdBindPipeline-pipelineBindPoint-parameter
pipelineBindPoint must be a valid VkPipelineBindPoint value
VUID-vkCmdBindPipeline-pipeline-parameter
pipeline must be a valid VkPipeline handle
VUID-vkCmdBindPipeline-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdBindPipeline-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
VUID-vkCmdBindPipeline-commonparent
Both of commandBuffer, and pipeline must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

Possible values of vkCmdBindPipeline::pipelineBindPoint, specifying the bind point of a pipeline object, are:

typedef enum VkPipelineBindPoint {
    VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
    VK_PIPELINE_BIND_POINT_COMPUTE = 1,
    VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = 1000165000,
    VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
} VkPipelineBindPoint;

VK_PIPELINE_BIND_POINT_COMPUTE specifies binding as a compute pipeline.
VK_PIPELINE_BIND_POINT_GRAPHICS specifies binding as a graphics pipeline.
VK_PIPELINE_BIND_POINT_RAY_TRACING_NV specifies binding as a ray tracing pipeline.

9.9. Dynamic State

When a pipeline object is bound, any pipeline object state that is not specified as dynamic is applied to the command buffer state. Pipeline object state that is specified as dynamic is not applied to the command buffer state at this time. Instead, dynamic state can be modified at any time and persists for the lifetime of the command buffer, or until modified by another dynamic state setting command or another pipeline bind.

When a pipeline object is bound, the following applies to each state parameter:

If the state is not specified as dynamic in the new pipeline object, then that command buffer state is overwritten by the state in the new pipeline object. Before any draw or dispatch call with this pipeline there must not have been any call to any of the corresponding dynamic state setting commands after this pipeline was bound
If the state is specified as dynamic in the new pipeline object, then that command buffer state is not disturbed. Before any draw or dispatch call with this pipeline there must have been at least one call to each of the corresponding dynamic state setting commands since the command buffer recording was begun, or the last bound pipeline object with that state specified as static, whichever was the latter

Dynamic state that does not affect the result of operations can be left undefined.

Note

For example, if blending is disabled by the pipeline object state then the dynamic color blend constants do not need to be specified in the command buffer, even if this state is specified as dynamic in the pipeline object.

9.10. Pipeline Shader Information

When a pipeline is created, its state and shaders are compiled into zero or more device-specific executables, which are used when executing commands against that pipeline. To query the properties of these executables, call:

VkResult vkGetPipelineExecutablePropertiesKHR(
    VkDevice                                    device,
    const VkPipelineInfoKHR*                    pPipelineInfo,
    uint32_t*                                   pExecutableCount,
    VkPipelineExecutablePropertiesKHR*          pProperties);

device is the device that created the pipeline.
pPipelineInfo describes the pipeline being queried.
pExecutableCount is a pointer to an integer related to the number of pipeline executables available or queried, as described below.
pProperties is either NULL or a pointer to an array of VkPipelineExecutablePropertiesKHR structures.

If pProperties is NULL, then the number of executables associated with the pipeline is returned in pExecutableCount. Otherwise, pExecutableCount 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 pExecutableCount is less than the number of executables associated with the pipeline, at most pExecutableCount structures will be written and vkGetPipelineExecutablePropertiesKHR will return VK_INCOMPLETE.

Valid Usage

VUID-vkGetPipelineExecutablePropertiesKHR-pipelineExecutableInfo-03270
pipelineExecutableInfo must be enabled.
VUID-vkGetPipelineExecutablePropertiesKHR-pipeline-03271
pipeline member of pPipelineInfo must have been created with device.

Valid Usage (Implicit)

VUID-vkGetPipelineExecutablePropertiesKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkGetPipelineExecutablePropertiesKHR-pPipelineInfo-parameter
pPipelineInfo must be a valid pointer to a valid VkPipelineInfoKHR structure
VUID-vkGetPipelineExecutablePropertiesKHR-pExecutableCount-parameter
pExecutableCount must be a valid pointer to a uint32_t value
VUID-vkGetPipelineExecutablePropertiesKHR-pProperties-parameter
If the value referenced by pExecutableCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pExecutableCount VkPipelineExecutablePropertiesKHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkPipelineInfoKHR structure is defined as:

typedef struct VkPipelineInfoKHR {
    VkStructureType    sType;
    const void*        pNext;
    VkPipeline         pipeline;
} VkPipelineInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
pipeline is a VkPipeline handle.

Valid Usage (Implicit)

VUID-VkPipelineInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR
VUID-VkPipelineInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkPipelineInfoKHR-pipeline-parameter
pipeline must be a valid VkPipeline handle

The VkPipelineExecutablePropertiesKHR structure is defined as:

typedef struct VkPipelineExecutablePropertiesKHR {
    VkStructureType       sType;
    void*                 pNext;
    VkShaderStageFlags    stages;
    char                  name[VK_MAX_DESCRIPTION_SIZE];
    char                  description[VK_MAX_DESCRIPTION_SIZE];
    uint32_t              subgroupSize;
} VkPipelineExecutablePropertiesKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
stages is a bitmask of VkShaderStageFlagBits indicating which shader stages (if any) were principally used as inputs to compile this pipeline executable.
name is an array of VK_MAX_DESCRIPTION_SIZE char containing a null-terminated UTF-8 string which is a short human readable name for this executable.
description is an array of VK_MAX_DESCRIPTION_SIZE char containing a null-terminated UTF-8 string which is a human readable description for this executable.
subgroupSize is the subgroup size with which this executable is dispatched.

The stages field may be zero or it may contain one or more bits describing the stages principally used to compile this pipeline. Not all implementations have a 1:1 mapping between shader stages and pipeline executables and some implementations may reduce a given shader stage to fixed function hardware programming such that no executable is available. No guarantees are provided about the mapping between shader stages and pipeline executables and stages should be considered a best effort hint. Because the application cannot rely on the stages field to provide an exact description, name and description provide a human readable name and description which more accurately describes the given pipeline executable.

Valid Usage (Implicit)

VUID-VkPipelineExecutablePropertiesKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR
VUID-VkPipelineExecutablePropertiesKHR-pNext-pNext
pNext must be NULL

Each pipeline executable may have a set of statistics associated with it that are generated by the pipeline compilation process. These statistics may include things such as instruction counts, amount of spilling (if any), maximum number of simultaneous threads, or anything else which may aid developers in evaluating the expected performance of a shader. To query the compile-time statistics associated with a pipeline executable, call:

VkResult vkGetPipelineExecutableStatisticsKHR(
    VkDevice                                    device,
    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
    uint32_t*                                   pStatisticCount,
    VkPipelineExecutableStatisticKHR*           pStatistics);

device is the device that created the pipeline.
pExecutableInfo describes the pipeline executable being queried.
pStatisticCount is a pointer to an integer related to the number of statistics available or queried, as described below.
pStatistics is either NULL or a pointer to an array of VkPipelineExecutableStatisticKHR structures.

If pStatistics is NULL, then the number of statistics associated with the pipeline executable is returned in pStatisticCount. Otherwise, pStatisticCount must point to a variable set by the user to the number of elements in the pStatistics array, and on return the variable is overwritten with the number of structures actually written to pStatistics. If pStatisticCount is less than the number of statistics associated with the pipeline executable, at most pStatisticCount structures will be written and vkGetPipelineExecutableStatisticsKHR will return VK_INCOMPLETE.

Valid Usage

VUID-vkGetPipelineExecutableStatisticsKHR-pipelineExecutableInfo-03272
pipelineExecutableInfo must be enabled.
VUID-vkGetPipelineExecutableStatisticsKHR-pipeline-03273
pipeline member of pExecutableInfo must have been created with device.
VUID-vkGetPipelineExecutableStatisticsKHR-pipeline-03274
pipeline member of pExecutableInfo must have been created with VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR set in the flags field of VkGraphicsPipelineCreateInfo or VkComputePipelineCreateInfo.

Valid Usage (Implicit)

VUID-vkGetPipelineExecutableStatisticsKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkGetPipelineExecutableStatisticsKHR-pExecutableInfo-parameter
pExecutableInfo must be a valid pointer to a valid VkPipelineExecutableInfoKHR structure
VUID-vkGetPipelineExecutableStatisticsKHR-pStatisticCount-parameter
pStatisticCount must be a valid pointer to a uint32_t value
VUID-vkGetPipelineExecutableStatisticsKHR-pStatistics-parameter
If the value referenced by pStatisticCount is not 0, and pStatistics is not NULL, pStatistics must be a valid pointer to an array of pStatisticCount VkPipelineExecutableStatisticKHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkPipelineExecutableInfoKHR structure is defined as:

typedef struct VkPipelineExecutableInfoKHR {
    VkStructureType    sType;
    const void*        pNext;
    VkPipeline         pipeline;
    uint32_t           executableIndex;
} VkPipelineExecutableInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
pipeline is the pipeline to query.
executableIndex is the index of the executable to query in the array of executable properties returned by vkGetPipelineExecutablePropertiesKHR.

Valid Usage

VUID-VkPipelineExecutableInfoKHR-executableIndex-03275
executableIndex must be less than the number of executables associated with pipeline as returned in the pExecutableCount parameter of vkGetPipelineExecutablePropertiesKHR.

Valid Usage (Implicit)

VUID-VkPipelineExecutableInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR
VUID-VkPipelineExecutableInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkPipelineExecutableInfoKHR-pipeline-parameter
pipeline must be a valid VkPipeline handle

The VkPipelineExecutableStatisticKHR structure is defined as:

typedef struct VkPipelineExecutableStatisticKHR {
    VkStructureType                           sType;
    void*                                     pNext;
    char                                      name[VK_MAX_DESCRIPTION_SIZE];
    char                                      description[VK_MAX_DESCRIPTION_SIZE];
    VkPipelineExecutableStatisticFormatKHR    format;
    VkPipelineExecutableStatisticValueKHR     value;
} VkPipelineExecutableStatisticKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
name is an array of VK_MAX_DESCRIPTION_SIZE char containing a null-terminated UTF-8 string which is a short human readable name for this statistic.
description is an array of VK_MAX_DESCRIPTION_SIZE char containing a null-terminated UTF-8 string which is a human readable description for this statistic.
format is a VkPipelineExecutableStatisticFormatKHR value specifying the format of the data found in value.
value is the value of this statistic.

Valid Usage (Implicit)

VUID-VkPipelineExecutableStatisticKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR
VUID-VkPipelineExecutableStatisticKHR-pNext-pNext
pNext must be NULL

The VkPipelineExecutableStatisticFormatKHR enum is defined as:

typedef enum VkPipelineExecutableStatisticFormatKHR {
    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0,
    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1,
    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2,
    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3,
    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF
} VkPipelineExecutableStatisticFormatKHR;

VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR specifies that the statistic is returned as a 32-bit boolean value which must be either VK_TRUE or VK_FALSE and should be read from the b32 field of VkPipelineExecutableStatisticValueKHR.
VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR specifies that the statistic is returned as a signed 64-bit integer and should be read from the i64 field of VkPipelineExecutableStatisticValueKHR.
VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR specifies that the statistic is returned as an unsigned 64-bit integer and should be read from the u64 field of VkPipelineExecutableStatisticValueKHR.
VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR specifies that the statistic is returned as a 64-bit floating-point value and should be read from the f64 field of VkPipelineExecutableStatisticValueKHR.

The VkPipelineExecutableStatisticValueKHR union is defined as:

typedef union VkPipelineExecutableStatisticValueKHR {
    VkBool32    b32;
    int64_t     i64;
    uint64_t    u64;
    double      f64;
} VkPipelineExecutableStatisticValueKHR;

b32 is the 32-bit boolean value if the VkPipelineExecutableStatisticFormatKHR is VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR.
i64 is the signed 64-bit integer value if the VkPipelineExecutableStatisticFormatKHR is VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR.
u64 is the unsigned 64-bit integer value if the VkPipelineExecutableStatisticFormatKHR is VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR.
f64 is the 64-bit floating-point value if the VkPipelineExecutableStatisticFormatKHR is VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR.

Each pipeline executable may have one or more text or binary internal representations associated with it which are generated as part of the compile process. These may include the final shader assembly, a binary form of the compiled shader, or the shader compiler’s internal representation at any number of intermediate compile steps. To query the internal representations associated with a pipeline executable, call:

VkResult vkGetPipelineExecutableInternalRepresentationsKHR(
    VkDevice                                    device,
    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
    uint32_t*                                   pInternalRepresentationCount,
    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);

device is the device that created the pipeline.
pExecutableInfo describes the pipeline executable being queried.
pInternalRepresentationCount is a pointer to an integer related to the number of internal representations available or queried, as described below.
pInternalRepresentations is either NULL or a pointer to an array of VkPipelineExecutableInternalRepresentationKHR structures.

If pInternalRepresentations is NULL, then the number of internal representations associated with the pipeline executable is returned in pInternalRepresentationCount. Otherwise, pInternalRepresentationCount must point to a variable set by the user to the number of elements in the pInternalRepresentations array, and on return the variable is overwritten with the number of structures actually written to pInternalRepresentations. If pInternalRepresentationCount is less than the number of internal representations associated with the pipeline executable, at most pInternalRepresentationCount structures will be written and vkGetPipelineExecutableInternalRepresentationsKHR will return VK_INCOMPLETE.

While the details of the internal representations remain implementation dependent, the implementation should order the internal representations in the order in which they occur in the compile pipeline with the final shader assembly (if any) last.

Valid Usage

VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipelineExecutableInfo-03276
pipelineExecutableInfo must be enabled.
VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipeline-03277
pipeline member of pExecutableInfo must have been created with device.
VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipeline-03278
pipeline member of pExecutableInfo must have been created with VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR set in the flags field of VkGraphicsPipelineCreateInfo or VkComputePipelineCreateInfo.

Valid Usage (Implicit)

VUID-vkGetPipelineExecutableInternalRepresentationsKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pExecutableInfo-parameter
pExecutableInfo must be a valid pointer to a valid VkPipelineExecutableInfoKHR structure
VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pInternalRepresentationCount-parameter
pInternalRepresentationCount must be a valid pointer to a uint32_t value
VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pInternalRepresentations-parameter
If the value referenced by pInternalRepresentationCount is not 0, and pInternalRepresentations is not NULL, pInternalRepresentations must be a valid pointer to an array of pInternalRepresentationCount VkPipelineExecutableInternalRepresentationKHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkPipelineExecutableInternalRepresentationKHR structure is defined as:

typedef struct VkPipelineExecutableInternalRepresentationKHR {
    VkStructureType    sType;
    void*              pNext;
    char               name[VK_MAX_DESCRIPTION_SIZE];
    char               description[VK_MAX_DESCRIPTION_SIZE];
    VkBool32           isText;
    size_t             dataSize;
    void*              pData;
} VkPipelineExecutableInternalRepresentationKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
name is an array of VK_MAX_DESCRIPTION_SIZE char containing a null-terminated UTF-8 string which is a short human readable name for this internal representation.
description is an array of VK_MAX_DESCRIPTION_SIZE char containing a null-terminated UTF-8 string which is a human readable description for this internal representation.
isText specifies whether the returned data is text or opaque data. If isText is VK_TRUE then the data returned in pData is text and is guaranteed to be a null-terminated UTF-8 string.
dataSize is an integer related to the size, in bytes, of the internal representation data, as described below.
pData is either NULL or a pointer to an block of data into which the implementation will write the textual form of the internal representation.

If pData is NULL, then the size, in bytes, of the internal representation data is returned in dataSize. Otherwise, dataSize must be the size of the buffer, in bytes, pointed to by pData and on return dataSize is overwritten with the number of bytes of data actually written to pData including any trailing null character. If dataSize is less than the size, in bytes, of the internal representation data, at most dataSize bytes of data will be written to pData and vkGetPipelineExecutableInternalRepresentationsKHR will return VK_INCOMPLETE. If isText is VK_TRUE and pData is not NULL and dataSize is not zero, the last byte written to pData will be a null character.

Valid Usage (Implicit)

VUID-VkPipelineExecutableInternalRepresentationKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR
VUID-VkPipelineExecutableInternalRepresentationKHR-pNext-pNext
pNext must be NULL

Information about a particular shader that has been compiled as part of a pipeline object can be extracted by calling:

VkResult vkGetShaderInfoAMD(
    VkDevice                                    device,
    VkPipeline                                  pipeline,
    VkShaderStageFlagBits                       shaderStage,
    VkShaderInfoTypeAMD                         infoType,
    size_t*                                     pInfoSize,
    void*                                       pInfo);

device is the device that created pipeline.
pipeline is the target of the query.
shaderStage identifies the particular shader within the pipeline about which information is being queried.
infoType describes what kind of information is being queried.
pInfoSize is a pointer to a value related to the amount of data the query returns, as described below.
pInfo is either NULL or a pointer to a buffer.

If pInfo is NULL, then the maximum size of the information that can be retrieved about the shader, in bytes, is returned in pInfoSize. Otherwise, pInfoSize must point to a variable set by the user to the size of the buffer, in bytes, pointed to by pInfo, and on return the variable is overwritten with the amount of data actually written to pInfo.

If pInfoSize is less than the maximum size that can be retrieved by the pipeline cache, then at most pInfoSize bytes will be written to pInfo, and vkGetShaderInfoAMD will return VK_INCOMPLETE.

Not all information is available for every shader and implementations may not support all kinds of information for any shader. When a certain type of information is unavailable, the function returns VK_ERROR_FEATURE_NOT_PRESENT.

If information is successfully and fully queried, the function will return VK_SUCCESS.

For infoType VK_SHADER_INFO_TYPE_STATISTICS_AMD, a VkShaderStatisticsInfoAMD structure will be written to the buffer pointed to by pInfo. This structure will be populated with statistics regarding the physical device resources used by that shader along with other miscellaneous information and is described in further detail below.

For infoType VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD, pInfo is a pointer to a UTF-8 null-terminated string containing human-readable disassembly. The exact formatting and contents of the disassembly string are vendor-specific.

The formatting and contents of all other types of information, including infoType VK_SHADER_INFO_TYPE_BINARY_AMD, are left to the vendor and are not further specified by this extension.

Valid Usage (Implicit)

VUID-vkGetShaderInfoAMD-device-parameter
device must be a valid VkDevice handle
VUID-vkGetShaderInfoAMD-pipeline-parameter
pipeline must be a valid VkPipeline handle
VUID-vkGetShaderInfoAMD-shaderStage-parameter
shaderStage must be a valid VkShaderStageFlagBits value
VUID-vkGetShaderInfoAMD-infoType-parameter
infoType must be a valid VkShaderInfoTypeAMD value
VUID-vkGetShaderInfoAMD-pInfoSize-parameter
pInfoSize must be a valid pointer to a size_t value
VUID-vkGetShaderInfoAMD-pInfo-parameter
If the value referenced by pInfoSize is not 0, and pInfo is not NULL, pInfo must be a valid pointer to an array of pInfoSize bytes
VUID-vkGetShaderInfoAMD-pipeline-parent
pipeline must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_FEATURE_NOT_PRESENT
VK_ERROR_OUT_OF_HOST_MEMORY

Possible values of vkGetShaderInfoAMD::infoType, specifying the information being queried from a shader, are:

typedef enum VkShaderInfoTypeAMD {
    VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0,
    VK_SHADER_INFO_TYPE_BINARY_AMD = 1,
    VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2,
    VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF
} VkShaderInfoTypeAMD;

VK_SHADER_INFO_TYPE_STATISTICS_AMD specifies that device resources used by a shader will be queried.
VK_SHADER_INFO_TYPE_BINARY_AMD specifies that implementation-specific information will be queried.
VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD specifies that human-readable dissassembly of a shader.

The VkShaderStatisticsInfoAMD structure is defined as:

typedef struct VkShaderStatisticsInfoAMD {
    VkShaderStageFlags          shaderStageMask;
    VkShaderResourceUsageAMD    resourceUsage;
    uint32_t                    numPhysicalVgprs;
    uint32_t                    numPhysicalSgprs;
    uint32_t                    numAvailableVgprs;
    uint32_t                    numAvailableSgprs;
    uint32_t                    computeWorkGroupSize[3];
} VkShaderStatisticsInfoAMD;

shaderStageMask are the combination of logical shader stages contained within this shader.
resourceUsage is a VkShaderResourceUsageAMD structure describing internal physical device resources used by this shader.
numPhysicalVgprs is the maximum number of vector instruction general-purpose registers (VGPRs) available to the physical device.
numPhysicalSgprs is the maximum number of scalar instruction general-purpose registers (SGPRs) available to the physical device.
numAvailableVgprs is the maximum limit of VGPRs made available to the shader compiler.
numAvailableSgprs is the maximum limit of SGPRs made available to the shader compiler.
computeWorkGroupSize is the local workgroup size of this shader in { X, Y, Z } dimensions.

Some implementations may merge multiple logical shader stages together in a single shader. In such cases, shaderStageMask will contain a bitmask of all of the stages that are active within that shader. Consequently, if specifying those stages as input to vkGetShaderInfoAMD, the same output information may be returned for all such shader stage queries.

The number of available VGPRs and SGPRs (numAvailableVgprs and numAvailableSgprs respectively) are the shader-addressable subset of physical registers that is given as a limit to the compiler for register assignment. These values may further be limited by implementations due to performance optimizations where register pressure is a bottleneck.

The VkShaderResourceUsageAMD structure is defined as:

typedef struct VkShaderResourceUsageAMD {
    uint32_t    numUsedVgprs;
    uint32_t    numUsedSgprs;
    uint32_t    ldsSizePerLocalWorkGroup;
    size_t      ldsUsageSizeInBytes;
    size_t      scratchMemUsageInBytes;
} VkShaderResourceUsageAMD;

numUsedVgprs is the number of vector instruction general-purpose registers used by this shader.
numUsedSgprs is the number of scalar instruction general-purpose registers used by this shader.
ldsSizePerLocalWorkGroup is the maximum local data store size per work group in bytes.
ldsUsageSizeInBytes is the LDS usage size in bytes per work group by this shader.
scratchMemUsageInBytes is the scratch memory usage in bytes by this shader.

9.11. Pipeline Compiler Control

The compilation of a pipeline can be tuned by adding a VkPipelineCompilerControlCreateInfoAMD structure to the pNext chain of VkGraphicsPipelineCreateInfo or VkComputePipelineCreateInfo.

typedef struct VkPipelineCompilerControlCreateInfoAMD {
    VkStructureType                      sType;
    const void*                          pNext;
    VkPipelineCompilerControlFlagsAMD    compilerControlFlags;
} VkPipelineCompilerControlCreateInfoAMD;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
compilerControlFlags is a bitmask of VkPipelineCompilerControlFlagBitsAMD affecting how the pipeline will be compiled.

Valid Usage (Implicit)

VUID-VkPipelineCompilerControlCreateInfoAMD-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD
VUID-VkPipelineCompilerControlCreateInfoAMD-compilerControlFlags-zerobitmask
compilerControlFlags must be 0

There are currently no available flags for this extension; flags will be added by future versions of this extension.

typedef enum VkPipelineCompilerControlFlagBitsAMD {
    VK_PIPELINE_COMPILER_CONTROL_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF
} VkPipelineCompilerControlFlagBitsAMD;

9.12. Ray Tracing Pipeline

Ray tracing pipelines consist of multiple shader stages, fixed-function traversal stages, and a pipeline layout.

To create ray tracing pipelines, call:

VkResult vkCreateRayTracingPipelinesNV(
    VkDevice                                    device,
    VkPipelineCache                             pipelineCache,
    uint32_t                                    createInfoCount,
    const VkRayTracingPipelineCreateInfoNV*     pCreateInfos,
    const VkAllocationCallbacks*                pAllocator,
    VkPipeline*                                 pPipelines);

device is the logical device that creates the ray tracing pipelines.
pipelineCache is either VK_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.
createInfoCount is the length of the pCreateInfos and pPipelines arrays.
pCreateInfos is a pointer to an array of VkRayTracingPipelineCreateInfoNV structures.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pPipelines is a pointer to an array in which the resulting ray tracing pipeline objects are returned.

Valid Usage

VUID-vkCreateRayTracingPipelinesNV-flags-02402
If the flags member of any element of pCreateInfos contains the VK_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
VUID-vkCreateRayTracingPipelinesNV-flags-02403
If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set

Valid Usage (Implicit)

VUID-vkCreateRayTracingPipelinesNV-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateRayTracingPipelinesNV-pipelineCache-parameter
If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle
VUID-vkCreateRayTracingPipelinesNV-pCreateInfos-parameter
pCreateInfos must be a valid pointer to an array of createInfoCount valid VkRayTracingPipelineCreateInfoNV structures
VUID-vkCreateRayTracingPipelinesNV-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateRayTracingPipelinesNV-pPipelines-parameter
pPipelines must be a valid pointer to an array of createInfoCount VkPipeline handles
VUID-vkCreateRayTracingPipelinesNV-createInfoCount-arraylength
createInfoCount must be greater than 0
VUID-vkCreateRayTracingPipelinesNV-pipelineCache-parent
If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INVALID_SHADER_NV

The VkRayTracingPipelineCreateInfoNV structure is defined as:

typedef struct VkRayTracingPipelineCreateInfoNV {
    VkStructureType                               sType;
    const void*                                   pNext;
    VkPipelineCreateFlags                         flags;
    uint32_t                                      stageCount;
    const VkPipelineShaderStageCreateInfo*        pStages;
    uint32_t                                      groupCount;
    const VkRayTracingShaderGroupCreateInfoNV*    pGroups;
    uint32_t                                      maxRecursionDepth;
    VkPipelineLayout                              layout;
    VkPipeline                                    basePipelineHandle;
    int32_t                                       basePipelineIndex;
} VkRayTracingPipelineCreateInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkPipelineCreateFlagBits specifying how the pipeline will be generated.
stageCount is the number of entries in the pStages array.
pStages is a pointer to an array of stageCount VkPipelineShaderStageCreateInfo structures describing the set of the shader stages to be included in the ray tracing pipeline.
groupCount is the number of entries in the pGroups array.
pGroups is a pointer to an array of groupCount VkRayTracingShaderGroupCreateInfoNV structures describing the set of the shader stages to be included in each shader group in the ray tracing pipeline.
maxRecursionDepth is the maximum recursion that will be called from this pipeline.
layout is the description of binding locations used by both the pipeline and descriptor sets used with the pipeline.
basePipelineHandle is a pipeline to derive from.
basePipelineIndex is an index into the pCreateInfos parameter to use as a pipeline to derive from.

The parameters basePipelineHandle and basePipelineIndex are described in more detail in Pipeline Derivatives.

Valid Usage

VUID-VkRayTracingPipelineCreateInfoNV-flags-02404
If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a ray tracing VkPipeline
VUID-VkRayTracingPipelineCreateInfoNV-flags-02405
If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command’s pCreateInfos parameter
VUID-VkRayTracingPipelineCreateInfoNV-flags-02406
If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE
VUID-VkRayTracingPipelineCreateInfoNV-flags-02407
If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1
VUID-VkRayTracingPipelineCreateInfoNV-stage-02408
The stage member of one element of pStages must be VK_SHADER_STAGE_RAYGEN_BIT_NV
VUID-VkRayTracingPipelineCreateInfoNV-pStages-02409
The shader code for the entry points identified by pStages, and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter
VUID-VkRayTracingPipelineCreateInfoNV-layout-02410
layout must be consistent with all shaders specified in pStages
VUID-VkRayTracingPipelineCreateInfoNV-layout-02411
The number of resources in layout accessible to each shader stage that is used by the pipeline must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources
VUID-VkRayTracingPipelineCreateInfoNV-maxRecursionDepth-02412
maxRecursionDepth must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxRecursionDepth

Valid Usage (Implicit)

VUID-VkRayTracingPipelineCreateInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV
VUID-VkRayTracingPipelineCreateInfoNV-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkPipelineCreationFeedbackCreateInfoEXT
VUID-VkRayTracingPipelineCreateInfoNV-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkRayTracingPipelineCreateInfoNV-flags-parameter
flags must be a valid combination of VkPipelineCreateFlagBits values
VUID-VkRayTracingPipelineCreateInfoNV-pStages-parameter
pStages must be a valid pointer to an array of stageCount valid VkPipelineShaderStageCreateInfo structures
VUID-VkRayTracingPipelineCreateInfoNV-pGroups-parameter
pGroups must be a valid pointer to an array of groupCount valid VkRayTracingShaderGroupCreateInfoNV structures
VUID-VkRayTracingPipelineCreateInfoNV-layout-parameter
layout must be a valid VkPipelineLayout handle
VUID-VkRayTracingPipelineCreateInfoNV-stageCount-arraylength
stageCount must be greater than 0
VUID-VkRayTracingPipelineCreateInfoNV-groupCount-arraylength
groupCount must be greater than 0
VUID-VkRayTracingPipelineCreateInfoNV-commonparent
Both of basePipelineHandle, and layout that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

The VkRayTracingShaderGroupCreateInfoNV structure is defined as:

typedef struct VkRayTracingShaderGroupCreateInfoNV {
    VkStructureType                  sType;
    const void*                      pNext;
    VkRayTracingShaderGroupTypeNV    type;
    uint32_t                         generalShader;
    uint32_t                         closestHitShader;
    uint32_t                         anyHitShader;
    uint32_t                         intersectionShader;
} VkRayTracingShaderGroupCreateInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
type is the type of hit group specified in this structure.
generalShader is the index of the ray generation, miss, or callable shader from VkRayTracingPipelineCreateInfoNV::pStages in the group if the shader group has type of VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV and VK_SHADER_UNUSED_NV otherwise.
closestHitShader is the optional index of the closest hit shader from VkRayTracingPipelineCreateInfoNV::pStages in the group if the shader group has type of VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV or VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV and VK_SHADER_UNUSED_NV otherwise.
anyHitShader is the optional index of the any-hit shader from VkRayTracingPipelineCreateInfoNV::pStages in the group if the shader group has type of VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV or VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV and VK_SHADER_UNUSED_NV otherwise.
intersectionShader is the index of the intersection shader from VkRayTracingPipelineCreateInfoNV::pStages in the group if the shader group has type of VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV and VK_SHADER_UNUSED_NV otherwise.

Valid Usage

VUID-VkRayTracingShaderGroupCreateInfoNV-type-02413
If type is VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV then generalShader must be a valid index into pStages referring to a shader of VK_SHADER_STAGE_RAYGEN_BIT_NV, VK_SHADER_STAGE_MISS_BIT_NV, or VK_SHADER_STAGE_CALLABLE_BIT_NV
VUID-VkRayTracingShaderGroupCreateInfoNV-type-02414
If type is VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV then closestHitShader, anyHitShader, and intersectionShader must be VK_SHADER_UNUSED_NV
VUID-VkRayTracingShaderGroupCreateInfoNV-type-02415
If type is VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV then intersectionShader must be a valid index into pStages referring to a shader of VK_SHADER_STAGE_INTERSECTION_BIT_NV
VUID-VkRayTracingShaderGroupCreateInfoNV-type-02416
If type is VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV then intersectionShader must be VK_SHADER_UNUSED_NV
VUID-VkRayTracingShaderGroupCreateInfoNV-closestHitShader-02417
closestHitShader must be either VK_SHADER_UNUSED_NV or a valid index into pStages referring to a shader of VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV
VUID-VkRayTracingShaderGroupCreateInfoNV-anyHitShader-02418
anyHitShader must be either VK_SHADER_UNUSED_NV or a valid index into pStages referring to a shader of VK_SHADER_STAGE_ANY_HIT_BIT_NV

Valid Usage (Implicit)

VUID-VkRayTracingShaderGroupCreateInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV
VUID-VkRayTracingShaderGroupCreateInfoNV-pNext-pNext
pNext must be NULL
VUID-VkRayTracingShaderGroupCreateInfoNV-type-parameter
type must be a valid VkRayTracingShaderGroupTypeNV value

Possible values of type in VkRayTracingShaderGroupCreateInfoNV are:

typedef enum VkRayTracingShaderGroupTypeNV {
    VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = 0,
    VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = 1,
    VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = 2,
    VK_RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
} VkRayTracingShaderGroupTypeNV;

VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV indicates a shader group with a single VK_SHADER_STAGE_RAYGEN_BIT_NV, VK_SHADER_STAGE_MISS_BIT_NV, or VK_SHADER_STAGE_CALLABLE_BIT_NV shader in it.
VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV specifies a shader group that only hits triangles and must not contain an intersection shader, only closest hit and any-hit.
VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV specifies a shader group that only intersects with custom geometry and must contain an intersection shader and may contain closest hit and any-hit shaders.

Note

For current group types, the hit group type could be inferred from the presence or absence of the intersection shader, but we provide the type explicitly for future hit groups that do not have that property.

To query the opaque handles of shaders in the ray tracing pipeline, call:

VkResult vkGetRayTracingShaderGroupHandlesNV(
    VkDevice                                    device,
    VkPipeline                                  pipeline,
    uint32_t                                    firstGroup,
    uint32_t                                    groupCount,
    size_t                                      dataSize,
    void*                                       pData);

device is the logical device containing the ray tracing pipeline.
pipeline is the ray tracing pipeline object containing the shaders.
firstGroup is the index of the first group to retrieve a handle for from the VkRayTracingShaderGroupCreateInfoNV::pGroups array.
groupCount is the number of shader handles to retrieve.
dataSize is the size in bytes of the buffer pointed to by pData.
pData is a pointer to a user-allocated buffer where the results will be written.

Valid Usage

VUID-vkGetRayTracingShaderGroupHandlesNV-firstGroup-02419
The sum of firstGroup and groupCount must be less than the number of shader groups in pipeline.
VUID-vkGetRayTracingShaderGroupHandlesNV-dataSize-02420
dataSize must be at least VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupHandleSize × groupCount

Valid Usage (Implicit)

VUID-vkGetRayTracingShaderGroupHandlesNV-device-parameter
device must be a valid VkDevice handle
VUID-vkGetRayTracingShaderGroupHandlesNV-pipeline-parameter
pipeline must be a valid VkPipeline handle
VUID-vkGetRayTracingShaderGroupHandlesNV-pData-parameter
pData must be a valid pointer to an array of dataSize bytes
VUID-vkGetRayTracingShaderGroupHandlesNV-dataSize-arraylength
dataSize must be greater than 0
VUID-vkGetRayTracingShaderGroupHandlesNV-pipeline-parent
pipeline must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Ray tracing pipelines can contain more shaders than a graphics or compute pipeline, so to allow parallel compilation of shaders within a pipeline, an application can choose to defer compilation until a later point in time.

To compile a deferred shader in a pipeline call:

VkResult vkCompileDeferredNV(
    VkDevice                                    device,
    VkPipeline                                  pipeline,
    uint32_t                                    shader);

device is the logical device containing the ray tracing pipeline.
pipeline is the ray tracing pipeline object containing the shaders.
shader is the index of the shader to compile.

Valid Usage

VUID-vkCompileDeferredNV-pipeline-02237
pipeline must have been created with VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV
VUID-vkCompileDeferredNV-shader-02238
shader must not have been called as a deferred compile before

Valid Usage (Implicit)

VUID-vkCompileDeferredNV-device-parameter
device must be a valid VkDevice handle
VUID-vkCompileDeferredNV-pipeline-parameter
pipeline must be a valid VkPipeline handle
VUID-vkCompileDeferredNV-pipeline-parent
pipeline must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

9.13. Pipeline Creation Feedback

Feedback about the creation of a particular pipeline object can be obtained by adding a VkPipelineCreationFeedbackCreateInfoEXT structure to the pNext chain of VkGraphicsPipelineCreateInfo, VkRayTracingPipelineCreateInfoNV, or VkComputePipelineCreateInfo. The VkPipelineCreationFeedbackCreateInfoEXT structure is defined as:

typedef struct VkPipelineCreationFeedbackCreateInfoEXT {
    VkStructureType                   sType;
    const void*                       pNext;
    VkPipelineCreationFeedbackEXT*    pPipelineCreationFeedback;
    uint32_t                          pipelineStageCreationFeedbackCount;
    VkPipelineCreationFeedbackEXT*    pPipelineStageCreationFeedbacks;
} VkPipelineCreationFeedbackCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
pPipelineCreationFeedback is a pointer to a VkPipelineCreationFeedbackEXT structure.
pipelineStageCreationFeedbackCount is the number of elements in pPipelineStageCreationFeedbacks.
pPipelineStageCreationFeedbacks is a pointer to an array of pipelineStageCreationFeedbackCount VkPipelineCreationFeedbackEXT structures.

An implementation should write pipeline creation feedback to pPipelineCreationFeedback and may write pipeline stage creation feedback to pPipelineStageCreationFeedbacks. An implementation must set or clear the VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT in VkPipelineCreationFeedbackEXT::flags for pPipelineCreationFeedback and every element of pPipelineStageCreationFeedbacks.

Note

One common scenario for an implementation to skip per-stage feedback is when VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT is set in pPipelineCreationFeedback.

When chained to VkRayTracingPipelineCreateInfoNV or VkGraphicsPipelineCreateInfo, the i element of pPipelineStageCreationFeedbacks corresponds to the i element of VkRayTracingPipelineCreateInfoNV::pStages or VkGraphicsPipelineCreateInfo::pStages. When chained to VkComputePipelineCreateInfo, the first element of pPipelineStageCreationFeedbacks corresponds to VkComputePipelineCreateInfo::stage.

Valid Usage

VUID-VkPipelineCreationFeedbackCreateInfoEXT-pipelineStageCreationFeedbackCount-02668
When chained to VkGraphicsPipelineCreateInfo, VkPipelineCreationFeedbackEXT::pipelineStageCreationFeedbackCount must equal VkGraphicsPipelineCreateInfo::stageCount
VUID-VkPipelineCreationFeedbackCreateInfoEXT-pipelineStageCreationFeedbackCount-02669
When chained to VkComputePipelineCreateInfo, VkPipelineCreationFeedbackEXT::pipelineStageCreationFeedbackCount must equal 1
VUID-VkPipelineCreationFeedbackCreateInfoEXT-pipelineStageCreationFeedbackCount-02670
When chained to VkRayTracingPipelineCreateInfoNV, VkPipelineCreationFeedbackEXT::pipelineStageCreationFeedbackCount must equal VkRayTracingPipelineCreateInfoNV::stageCount

Valid Usage (Implicit)

VUID-VkPipelineCreationFeedbackCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT
VUID-VkPipelineCreationFeedbackCreateInfoEXT-pPipelineCreationFeedback-parameter
pPipelineCreationFeedback must be a valid pointer to a VkPipelineCreationFeedbackEXT structure
VUID-VkPipelineCreationFeedbackCreateInfoEXT-pPipelineStageCreationFeedbacks-parameter
pPipelineStageCreationFeedbacks must be a valid pointer to an array of pipelineStageCreationFeedbackCount VkPipelineCreationFeedbackEXT structures
VUID-VkPipelineCreationFeedbackCreateInfoEXT-pipelineStageCreationFeedbackCount-arraylength
pipelineStageCreationFeedbackCount must be greater than 0

The VkPipelineCreationFeedbackEXT structure is defined as:

typedef struct VkPipelineCreationFeedbackEXT {
    VkPipelineCreationFeedbackFlagsEXT    flags;
    uint64_t                              duration;
} VkPipelineCreationFeedbackEXT;

flags is a bitmask of VkPipelineCreationFeedbackFlagBitsEXT providing feedback about the creation of a pipeline or of a pipeline stage.
duration is the duration spent creating a pipeline or pipeline stage in nanoseconds.

If the VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT is not set in flags, an implementation must not set any other bits in flags, and all other VkPipelineCreationFeedbackEXT data members are undefined.

Possible values of the flags member of VkPipelineCreationFeedbackEXT are:

typedef enum VkPipelineCreationFeedbackFlagBitsEXT {
    VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = 0x00000001,
    VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = 0x00000002,
    VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = 0x00000004,
    VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
} VkPipelineCreationFeedbackFlagBitsEXT;

VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT indicates that the feedback information is valid.

VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT indicates that a readily usable pipeline or pipeline stage was found in the pipelineCache specified by the application in the pipeline creation command.

An implementation should set the VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT bit if it was able to avoid the large majority of pipeline or pipeline stage creation work by using the pipelineCache parameter of vkCreateGraphicsPipelines, vkCreateRayTracingPipelinesNV, or vkCreateComputePipelines. When an implementation sets this bit for the entire pipeline, it may leave it unset for any stage.

Note

Implementations are encouraged to provide a meaningful signal to applications using this bit. The intention is to communicate to the application that the pipeline or pipeline stage was created "as fast as it gets" using the pipeline cache provided by the application. If an implementation uses an internal cache, it is discouraged from setting this bit as the feedback would be unactionable.

VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT indicates that the base pipeline specified by the basePipelineHandle or basePipelineIndex member of the Vk*PipelineCreateInfo structure was used to accelerate the creation of the pipeline.

An implementation should set the VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT bit if it was able to avoid a significant amount of work by using the base pipeline.

Note

While "significant amount of work" is subjective, implementations are encouraged to provide a meaningful signal to applications using this bit. For example, a 1% reduction in duration may not warrant setting this bit, while a 50% reduction would.

typedef VkFlags VkPipelineCreationFeedbackFlagsEXT;

VkPipelineCreationFeedbackFlagsEXT is a bitmask type for providing zero or more VkPipelineCreationFeedbackFlagBitsEXT.

10. Memory Allocation

Vulkan memory is broken up into two categories, host memory and device memory.

10.1. Host Memory

Host memory is memory needed by the Vulkan implementation for non-device-visible storage.

Note

This memory may be used to store the implementation’s representation and state of Vulkan objects.

Vulkan provides applications the opportunity to perform host memory allocations on behalf of the Vulkan implementation. If this feature is not used, the implementation will perform its own memory allocations. Since most memory allocations are off the critical path, this is not meant as a performance feature. Rather, this can be useful for certain embedded systems, for debugging purposes (e.g. putting a guard page after all host allocations), or for memory allocation logging.

Allocators are provided by the application as a pointer to a VkAllocationCallbacks structure:

typedef struct VkAllocationCallbacks {
    void*                                   pUserData;
    PFN_vkAllocationFunction                pfnAllocation;
    PFN_vkReallocationFunction              pfnReallocation;
    PFN_vkFreeFunction                      pfnFree;
    PFN_vkInternalAllocationNotification    pfnInternalAllocation;
    PFN_vkInternalFreeNotification          pfnInternalFree;
} VkAllocationCallbacks;

pUserData is a value to be interpreted by the implementation of the callbacks. When any of the callbacks in VkAllocationCallbacks are called, the Vulkan implementation will pass this value as the first parameter to the callback. This value can vary each time an allocator is passed into a command, even when the same object takes an allocator in multiple commands.
pfnAllocation is a PFN_vkAllocationFunction pointer to an application-defined memory allocation function.
pfnReallocation is a PFN_vkReallocationFunction pointer to an application-defined memory reallocation function.
pfnFree is a PFN_vkFreeFunction pointer to an application-defined memory free function.
pfnInternalAllocation is a PFN_vkInternalAllocationNotification pointer to an application-defined function that is called by the implementation when the implementation makes internal allocations.
pfnInternalFree is a PFN_vkInternalFreeNotification pointer to an application-defined function that is called by the implementation when the implementation frees internal allocations.

Valid Usage

VUID-VkAllocationCallbacks-pfnAllocation-00632
pfnAllocation must be a valid pointer to a valid user-defined PFN_vkAllocationFunction
VUID-VkAllocationCallbacks-pfnReallocation-00633
pfnReallocation must be a valid pointer to a valid user-defined PFN_vkReallocationFunction
VUID-VkAllocationCallbacks-pfnFree-00634
pfnFree must be a valid pointer to a valid user-defined PFN_vkFreeFunction
VUID-VkAllocationCallbacks-pfnInternalAllocation-00635
If either of pfnInternalAllocation or pfnInternalFree is not NULL, both must be valid callbacks

The type of pfnAllocation is:

typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
    void*                                       pUserData,
    size_t                                      size,
    size_t                                      alignment,
    VkSystemAllocationScope                     allocationScope);

pUserData is the value specified for VkAllocationCallbacks::pUserData in the allocator specified by the application.
size is the size in bytes of the requested allocation.
alignment is the requested alignment of the allocation in bytes and must be a power of two.
allocationScope is a VkSystemAllocationScope value specifying the allocation scope of the lifetime of the allocation, as described here.

If pfnAllocation is unable to allocate the requested memory, it must return NULL. If the allocation was successful, it must return a valid pointer to memory allocation containing at least size bytes, and with the pointer value being a multiple of alignment.

Note

Correct Vulkan operation cannot be assumed if the application does not follow these rules.

For example, pfnAllocation (or pfnReallocation) could cause termination of running Vulkan instance(s) on a failed allocation for debugging purposes, either directly or indirectly. In these circumstances, it cannot be assumed that any part of any affected VkInstance objects are going to operate correctly (even vkDestroyInstance), and the application must ensure it cleans up properly via other means (e.g. process termination).

If pfnAllocation returns NULL, and if the implementation is unable to continue correct processing of the current command without the requested allocation, it must treat this as a run-time error, and generate VK_ERROR_OUT_OF_HOST_MEMORY at the appropriate time for the command in which the condition was detected, as described in Return Codes.

If the implementation is able to continue correct processing of the current command without the requested allocation, then it may do so, and must not generate VK_ERROR_OUT_OF_HOST_MEMORY as a result of this failed allocation.

The type of pfnReallocation is:

typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
    void*                                       pUserData,
    void*                                       pOriginal,
    size_t                                      size,
    size_t                                      alignment,
    VkSystemAllocationScope                     allocationScope);

pUserData is the value specified for VkAllocationCallbacks::pUserData in the allocator specified by the application.
pOriginal must be either NULL or a pointer previously returned by pfnReallocation or pfnAllocation of a compatible allocator.
size is the size in bytes of the requested allocation.
alignment is the requested alignment of the allocation in bytes and must be a power of two.
allocationScope is a VkSystemAllocationScope value specifying the allocation scope of the lifetime of the allocation, as described here.

pfnReallocation must return an allocation with enough space for size bytes, and the contents of the original allocation from bytes zero to min(original size, new size) - 1 must be preserved in the returned allocation. If size is larger than the old size, the contents of the additional space are undefined. If satisfying these requirements involves creating a new allocation, then the old allocation should be freed.

If pOriginal is NULL, then pfnReallocation must behave equivalently to a call to PFN_vkAllocationFunction with the same parameter values (without pOriginal).

If size is zero, then pfnReallocation must behave equivalently to a call to PFN_vkFreeFunction with the same pUserData parameter value, and pMemory equal to pOriginal.

If pOriginal is non-NULL, the implementation must ensure that alignment is equal to the alignment used to originally allocate pOriginal.

If this function fails and pOriginal is non-NULL the application must not free the old allocation.

pfnReallocation must follow the same rules for return values as PFN_vkAllocationFunction.

The type of pfnFree is:

typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
    void*                                       pUserData,
    void*                                       pMemory);

pUserData is the value specified for VkAllocationCallbacks::pUserData in the allocator specified by the application.
pMemory is the allocation to be freed.

pMemory may be NULL, which the callback must handle safely. If pMemory is non-NULL, it must be a pointer previously allocated by pfnAllocation or pfnReallocation. The application should free this memory.

The type of pfnInternalAllocation is:

typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
    void*                                       pUserData,
    size_t                                      size,
    VkInternalAllocationType                    allocationType,
    VkSystemAllocationScope                     allocationScope);

pUserData is the value specified for VkAllocationCallbacks::pUserData in the allocator specified by the application.
size is the requested size of an allocation.
allocationType is a VkInternalAllocationType value specifying the requested type of an allocation.
allocationScope is a VkSystemAllocationScope value specifying the allocation scope of the lifetime of the allocation, as described here.

This is a purely informational callback.

The type of pfnInternalFree is:

typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
    void*                                       pUserData,
    size_t                                      size,
    VkInternalAllocationType                    allocationType,
    VkSystemAllocationScope                     allocationScope);

pUserData is the value specified for VkAllocationCallbacks::pUserData in the allocator specified by the application.
size is the requested size of an allocation.
allocationType is a VkInternalAllocationType value specifying the requested type of an allocation.
allocationScope is a VkSystemAllocationScope value specifying the allocation scope of the lifetime of the allocation, as described here.

Each allocation has an allocation scope defining its lifetime and which object it is associated with. Possible values passed to the allocationScope parameter of the callback functions specified by VkAllocationCallbacks, indicating the allocation scope, are:

typedef enum VkSystemAllocationScope {
    VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
    VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
    VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
    VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
    VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
} VkSystemAllocationScope;

VK_SYSTEM_ALLOCATION_SCOPE_COMMAND specifies that the allocation is scoped to the duration of the Vulkan command.
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT specifies that the allocation is scoped to the lifetime of the Vulkan object that is being created or used.
VK_SYSTEM_ALLOCATION_SCOPE_CACHE specifies that the allocation is scoped to the lifetime of a VkPipelineCache or VkValidationCacheEXT object.
VK_SYSTEM_ALLOCATION_SCOPE_DEVICE specifies that the allocation is scoped to the lifetime of the Vulkan device.
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE specifies that the allocation is scoped to the lifetime of the Vulkan instance.

Most Vulkan commands operate on a single object, or there is a sole object that is being created or manipulated. When an allocation uses an allocation scope of VK_SYSTEM_ALLOCATION_SCOPE_OBJECT or VK_SYSTEM_ALLOCATION_SCOPE_CACHE, the allocation is scoped to the object being created or manipulated.

When an implementation requires host memory, it will make callbacks to the application using the most specific allocator and allocation scope available:

If an allocation is scoped to the duration of a command, the allocator will use the VK_SYSTEM_ALLOCATION_SCOPE_COMMAND allocation scope. The most specific allocator available is used: if the object being created or manipulated has an allocator, that object’s allocator will be used, else if the parent VkDevice has an allocator it will be used, else if the parent VkInstance has an allocator it will be used. Else,
If an allocation is associated with a VkValidationCacheEXT or VkPipelineCache object, the allocator will use the VK_SYSTEM_ALLOCATION_SCOPE_CACHE allocation scope. The most specific allocator available is used (cache, else device, else instance). Else,
If an allocation is scoped to the lifetime of an object, that object is being created or manipulated by the command, and that object’s type is not VkDevice or VkInstance, the allocator will use an allocation scope of VK_SYSTEM_ALLOCATION_SCOPE_OBJECT. The most specific allocator available is used (object, else device, else instance). Else,
If an allocation is scoped to the lifetime of a device, the allocator will use an allocation scope of VK_SYSTEM_ALLOCATION_SCOPE_DEVICE. The most specific allocator available is used (device, else instance). Else,
If the allocation is scoped to the lifetime of an instance and the instance has an allocator, its allocator will be used with an allocation scope of VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE.
Otherwise an implementation will allocate memory through an alternative mechanism that is unspecified.

Objects that are allocated from pools do not specify their own allocator. When an implementation requires host memory for such an object, that memory is sourced from the object’s parent pool’s allocator.

The application is not expected to handle allocating memory that is intended for execution by the host due to the complexities of differing security implementations across multiple platforms. The implementation will allocate such memory internally and invoke an application provided informational callback when these internal allocations are allocated and freed. Upon allocation of executable memory, pfnInternalAllocation will be called. Upon freeing executable memory, pfnInternalFree will be called. An implementation will only call an informational callback for executable memory allocations and frees.

The allocationType parameter to the pfnInternalAllocation and pfnInternalFree functions may be one of the following values:

typedef enum VkInternalAllocationType {
    VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
    VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkInternalAllocationType;

VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE specifies that the allocation is intended for execution by the host.

An implementation must only make calls into an application-provided allocator during the execution of an API command. An implementation must only make calls into an application-provided allocator from the same thread that called the provoking API command. The implementation should not synchronize calls to any of the callbacks. If synchronization is needed, the callbacks must provide it themselves. The informational callbacks are subject to the same restrictions as the allocation callbacks.

If an implementation intends to make calls through a VkAllocationCallbacks structure between the time a vkCreate* command returns and the time a corresponding vkDestroy* command begins, that implementation must save a copy of the allocator before the vkCreate* command returns. The callback functions and any data structures they rely upon must remain valid for the lifetime of the object they are associated with.

If an allocator is provided to a vkCreate* command, a compatible allocator must be provided to the corresponding vkDestroy* command. Two VkAllocationCallbacks structures are compatible if memory allocated with pfnAllocation or pfnReallocation in each can be freed with pfnReallocation or pfnFree in the other. An allocator must not be provided to a vkDestroy* command if an allocator was not provided to the corresponding vkCreate* command.

If a non-NULL allocator is used, the pfnAllocation, pfnReallocation and pfnFree members must be non-NULL and point to valid implementations of the callbacks. An application can choose to not provide informational callbacks by setting both pfnInternalAllocation and pfnInternalFree to NULL. pfnInternalAllocation and pfnInternalFree must either both be NULL or both be non-NULL.

If pfnAllocation or pfnReallocation fail, the implementation may fail object creation and/or generate a VK_ERROR_OUT_OF_HOST_MEMORY error, as appropriate.

Allocation callbacks must not call any Vulkan commands.

The following sets of rules define when an implementation is permitted to call the allocator callbacks.

pfnAllocation or pfnReallocation may be called in the following situations:

Allocations scoped to a VkDevice or VkInstance may be allocated from any API command.
Allocations scoped to a command may be allocated from any API command.
Allocations scoped to a VkPipelineCache may only be allocated from:
- vkCreatePipelineCache
- vkMergePipelineCaches for dstCache
- vkCreateGraphicsPipelines for pipelineCache
- vkCreateComputePipelines for pipelineCache
Allocations scoped to a VkValidationCacheEXT may only be allocated from:
- vkCreateValidationCacheEXT
- vkMergeValidationCachesEXT for dstCache
- vkCreateShaderModule for validationCache in VkShaderModuleValidationCacheCreateInfoEXT
Allocations scoped to a VkDescriptorPool may only be allocated from:
- any command that takes the pool as a direct argument
- vkAllocateDescriptorSets for the descriptorPool member of its pAllocateInfo parameter
- vkCreateDescriptorPool
Allocations scoped to a VkCommandPool may only be allocated from:
- any command that takes the pool as a direct argument
- vkCreateCommandPool
- vkAllocateCommandBuffers for the commandPool member of its pAllocateInfo parameter
- any vkCmd* command whose commandBuffer was allocated from that VkCommandPool
Allocations scoped to any other object may only be allocated in that object’s vkCreate* command.

pfnFree, or pfnReallocation with zero size, may be called in the following situations:

Allocations scoped to a VkDevice or VkInstance may be freed from any API command.
Allocations scoped to a command must be freed by any API command which allocates such memory.
Allocations scoped to a VkPipelineCache may be freed from vkDestroyPipelineCache.
Allocations scoped to a VkValidationCacheEXT may be freed from vkDestroyValidationCacheEXT.
Allocations scoped to a VkDescriptorPool may be freed from
- any command that takes the pool as a direct argument
Allocations scoped to a VkCommandPool may be freed from:
- any command that takes the pool as a direct argument
- vkResetCommandBuffer whose commandBuffer was allocated from that VkCommandPool
Allocations scoped to any other object may be freed in that object’s vkDestroy* command.
Any command that allocates host memory may also free host memory of the same scope.

10.2. Device Memory

Device memory is memory that is visible to the device — for example the contents of the image or buffer objects, which can be natively used by the device.

Memory properties of a physical device describe the memory heaps and memory types available.

To query memory properties, call:

void vkGetPhysicalDeviceMemoryProperties(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceMemoryProperties*           pMemoryProperties);

physicalDevice is the handle to the device to query.
pMemoryProperties is a pointer to a VkPhysicalDeviceMemoryProperties structure in which the properties are returned.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceMemoryProperties-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceMemoryProperties-pMemoryProperties-parameter
pMemoryProperties must be a valid pointer to a VkPhysicalDeviceMemoryProperties structure

The VkPhysicalDeviceMemoryProperties structure is defined as:

typedef struct VkPhysicalDeviceMemoryProperties {
    uint32_t        memoryTypeCount;
    VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
    uint32_t        memoryHeapCount;
    VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
} VkPhysicalDeviceMemoryProperties;

memoryTypeCount is the number of valid elements in the memoryTypes array.
memoryTypes is an array of VK_MAX_MEMORY_TYPES VkMemoryType structures describing the memory types that can be used to access memory allocated from the heaps specified by memoryHeaps.
memoryHeapCount is the number of valid elements in the memoryHeaps array.
memoryHeaps is an array of VK_MAX_MEMORY_HEAPS VkMemoryHeap structures describing the memory heaps from which memory can be allocated.

The VkPhysicalDeviceMemoryProperties structure describes a number of memory heaps as well as a number of memory types that can be used to access memory allocated in those heaps. Each heap describes a memory resource of a particular size, and each memory type describes a set of memory properties (e.g. host cached vs uncached) that can be used with a given memory heap. Allocations using a particular memory type will consume resources from the heap indicated by that memory type’s heap index. More than one memory type may share each heap, and the heaps and memory types provide a mechanism to advertise an accurate size of the physical memory resources while allowing the memory to be used with a variety of different properties.

The number of memory heaps is given by memoryHeapCount and is less than or equal to VK_MAX_MEMORY_HEAPS. Each heap is described by an element of the memoryHeaps array as a VkMemoryHeap structure. The number of memory types available across all memory heaps is given by memoryTypeCount and is less than or equal to VK_MAX_MEMORY_TYPES. Each memory type is described by an element of the memoryTypes array as a VkMemoryType structure.

At least one heap must include VK_MEMORY_HEAP_DEVICE_LOCAL_BIT in VkMemoryHeap::flags. If there are multiple heaps that all have similar performance characteristics, they may all include VK_MEMORY_HEAP_DEVICE_LOCAL_BIT. In a unified memory architecture (UMA) system there is often only a single memory heap which is considered to be equally “local” to the host and to the device, and such an implementation must advertise the heap as device-local.

Each memory type returned by vkGetPhysicalDeviceMemoryProperties must have its propertyFlags set to one of the following values:

0
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_CACHED_BIT
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_CACHED_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_CACHED_BIT
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_CACHED_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT
VK_MEMORY_PROPERTY_PROTECTED_BIT
VK_MEMORY_PROPERTY_PROTECTED_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_CACHED_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_CACHED_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD |
VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_CACHED_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD |
VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD |
VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD |
VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_CACHED_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD |
VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD

There must be at least one memory type with both the VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT and VK_MEMORY_PROPERTY_HOST_COHERENT_BIT bits set in its propertyFlags. There must be at least one memory type with the VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT bit set in its propertyFlags. If the deviceCoherentMemory feature is enabled, there must be at least one memory type with the VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD bit set in its propertyFlags.

For each pair of elements X and Y returned in memoryTypes, X must be placed at a lower index position than Y if:

either the set of bit flags returned in the propertyFlags member of X is a strict subset of the set of bit flags returned in the propertyFlags member of Y; or
the propertyFlags members of X and Y are equal, and X belongs to a memory heap with greater performance (as determined in an implementation-specific manner) ; or
or the propertyFlags members of X includes VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD or VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD and Y does not

Note

There is no ordering requirement between X and Y elements for the case their propertyFlags members are not in a subset relation. That potentially allows more than one possible way to order the same set of memory types. Notice that the list of all allowed memory property flag combinations is written in a valid order. But if instead VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT was before VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, the list would still be in a valid order.

There may be a performance penalty for using device coherent or uncached device memory types, and using these accidentally is undesirable. In order to avoid this, memory types with these properties always appear at the end of the list; but are subject to the same rules otherwise.

This ordering requirement enables applications to use a simple search loop to select the desired memory type along the lines of:

// Find a memory in `memoryTypeBitsRequirement` that includes all of `requiredProperties`
int32_t findProperties(const VkPhysicalDeviceMemoryProperties* pMemoryProperties,
                       uint32_t memoryTypeBitsRequirement,
                       VkMemoryPropertyFlags requiredProperties) {
    const uint32_t memoryCount = pMemoryProperties->memoryTypeCount;
    for (uint32_t memoryIndex = 0; memoryIndex < memoryCount; ++memoryIndex) {
        const uint32_t memoryTypeBits = (1 << memoryIndex);
        const bool isRequiredMemoryType = memoryTypeBitsRequirement & memoryTypeBits;

        const VkMemoryPropertyFlags properties =
            pMemoryProperties->memoryTypes[memoryIndex].propertyFlags;
        const bool hasRequiredProperties =
            (properties & requiredProperties) == requiredProperties;

        if (isRequiredMemoryType && hasRequiredProperties)
            return static_cast<int32_t>(memoryIndex);
    }

    // failed to find memory type
    return -1;
}

// Try to find an optimal memory type, or if it does not exist try fallback memory type
// `device` is the VkDevice
// `image` is the VkImage that requires memory to be bound
// `memoryProperties` properties as returned by vkGetPhysicalDeviceMemoryProperties
// `requiredProperties` are the property flags that must be present
// `optimalProperties` are the property flags that are preferred by the application
VkMemoryRequirements memoryRequirements;
vkGetImageMemoryRequirements(device, image, &memoryRequirements);
int32_t memoryType =
    findProperties(&memoryProperties, memoryRequirements.memoryTypeBits, optimalProperties);
if (memoryType == -1) // not found; try fallback properties
    memoryType =
        findProperties(&memoryProperties, memoryRequirements.memoryTypeBits, requiredProperties);

To query memory properties, call:

void vkGetPhysicalDeviceMemoryProperties2(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);

or the equivalent command

void vkGetPhysicalDeviceMemoryProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);

physicalDevice is the handle to the device to query.
pMemoryProperties is a pointer to a VkPhysicalDeviceMemoryProperties2 structure in which the properties are returned.

vkGetPhysicalDeviceMemoryProperties2 behaves similarly to vkGetPhysicalDeviceMemoryProperties, with the ability to return extended information in a pNext chain of output structures.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceMemoryProperties2-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceMemoryProperties2-pMemoryProperties-parameter
pMemoryProperties must be a valid pointer to a VkPhysicalDeviceMemoryProperties2 structure

The VkPhysicalDeviceMemoryProperties2 structure is defined as:

typedef struct VkPhysicalDeviceMemoryProperties2 {
    VkStructureType                     sType;
    void*                               pNext;
    VkPhysicalDeviceMemoryProperties    memoryProperties;
} VkPhysicalDeviceMemoryProperties2;

or the equivalent

typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
memoryProperties is a VkPhysicalDeviceMemoryProperties structure which is populated with the same values as in vkGetPhysicalDeviceMemoryProperties.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceMemoryProperties2-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2
VUID-VkPhysicalDeviceMemoryProperties2-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkPhysicalDeviceMemoryBudgetPropertiesEXT
VUID-VkPhysicalDeviceMemoryProperties2-sType-unique
The sType value of each struct in the pNext chain must be unique

The VkMemoryHeap structure is defined as:

typedef struct VkMemoryHeap {
    VkDeviceSize         size;
    VkMemoryHeapFlags    flags;
} VkMemoryHeap;

size is the total memory size in bytes in the heap.
flags is a bitmask of VkMemoryHeapFlagBits specifying attribute flags for the heap.

Bits which may be set in VkMemoryHeap::flags, indicating attribute flags for the heap, are:

typedef enum VkMemoryHeapFlagBits {
    VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
    VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002,
    VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
    VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkMemoryHeapFlagBits;

VK_MEMORY_HEAP_DEVICE_LOCAL_BIT specifies that 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.
VK_MEMORY_HEAP_MULTI_INSTANCE_BIT specifies that in a logical device representing more than one physical device, there is a per-physical device instance of the heap memory. By default, an allocation from such a heap will be replicated to each physical device’s instance of the heap.

typedef VkFlags VkMemoryHeapFlags;

VkMemoryHeapFlags is a bitmask type for setting a mask of zero or more VkMemoryHeapFlagBits.

The VkMemoryType structure is defined as:

typedef struct VkMemoryType {
    VkMemoryPropertyFlags    propertyFlags;
    uint32_t                 heapIndex;
} VkMemoryType;

heapIndex describes which memory heap this memory type corresponds to, and must be less than memoryHeapCount from the VkPhysicalDeviceMemoryProperties structure.
propertyFlags is a bitmask of VkMemoryPropertyFlagBits of properties for this memory type.

Bits which may be set in VkMemoryType::propertyFlags, indicating properties of a memory heap, are:

typedef enum VkMemoryPropertyFlagBits {
    VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
    VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
    VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
    VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
    VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020,
    VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0x00000040,
    VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0x00000080,
    VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkMemoryPropertyFlagBits;

VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT bit specifies that memory allocated with this type is the most efficient for device access. This property will be set if and only if the memory type belongs to a heap with the VK_MEMORY_HEAP_DEVICE_LOCAL_BIT set.
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT bit specifies that memory allocated with this type can be mapped for host access using vkMapMemory.
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT bit specifies that the host cache management commands vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges are not needed to flush host writes to the device or make device writes visible to the host, respectively.
VK_MEMORY_PROPERTY_HOST_CACHED_BIT bit specifies that 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.
VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT bit specifies that the memory type only allows device access to the memory. Memory types must not have both VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT and VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT set. Additionally, the object’s backing memory may be provided by the implementation lazily as specified in Lazily Allocated Memory.
VK_MEMORY_PROPERTY_PROTECTED_BIT bit specifies that the memory type only allows device access to the memory, and allows protected queue operations to access the memory. Memory types must not have VK_MEMORY_PROPERTY_PROTECTED_BIT set and any of VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT set, or VK_MEMORY_PROPERTY_HOST_COHERENT_BIT set, or VK_MEMORY_PROPERTY_HOST_CACHED_BIT set.
VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD bit specifies that device accesses to allocations of this memory type are automatically made available and visible.
VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD bit specifies that memory allocated with this type is not cached on the device. Uncached device memory is always device coherent.

For any memory allocated with both the VK_MEMORY_PROPERTY_HOST_COHERENT_BIT and the VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD, host or device accesses also perform automatic memory domain transfer operations, such that writes are always automatically available and visible to both host and device memory domains.

Note

Device coherence is a useful property for certain debugging use cases (e.g. crash analysis, where performing separate coherence actions could mean values are not reported correctly). However, device coherent accesses may be slower than equivalent accesses without device coherence, particularly if they are also device uncached. For device uncached memory in particular, repeated accesses to the same or neighbouring memory locations over a short time period (e.g. within a frame) may be slower than it would be for the equivalent cached memory type. As such, it’s generally inadvisable to use device coherent or device uncached memory except when really needed.

typedef VkFlags VkMemoryPropertyFlags;

VkMemoryPropertyFlags is a bitmask type for setting a mask of zero or more VkMemoryPropertyFlagBits.

If the VkPhysicalDeviceMemoryBudgetPropertiesEXT structure is included in the pNext chain of VkPhysicalDeviceMemoryProperties2, it is filled with the current memory budgets and usages.

The VkPhysicalDeviceMemoryBudgetPropertiesEXT structure is defined as:

typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkDeviceSize       heapBudget[VK_MAX_MEMORY_HEAPS];
    VkDeviceSize       heapUsage[VK_MAX_MEMORY_HEAPS];
} VkPhysicalDeviceMemoryBudgetPropertiesEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
heapBudget is an array of VK_MAX_MEMORY_HEAPS VkDeviceSize values in which memory budgets are returned, with one element for each memory heap. A heap’s budget is a rough estimate of how much memory the process can allocate from that heap before allocations may fail or cause performance degradation. The budget includes any currently allocated device memory.
heapUsage is an array of VK_MAX_MEMORY_HEAPS VkDeviceSize values in which memory usages are returned, with one element for each memory heap. A heap’s usage is an estimate of how much memory the process is currently using in that heap.

The values returned in this structure are not invariant. The heapBudget and heapUsage values must be zero for array elements greater than or equal to VkPhysicalDeviceMemoryProperties::memoryHeapCount. The heapBudget value must be non-zero for array elements less than VkPhysicalDeviceMemoryProperties::memoryHeapCount. The heapBudget value must be less than or equal to VkMemoryHeap::size for each heap.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceMemoryBudgetPropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT

A Vulkan device operates on data in device memory via memory objects that are represented in the API by a VkDeviceMemory handle:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)

To allocate memory objects, call:

VkResult vkAllocateMemory(
    VkDevice                                    device,
    const VkMemoryAllocateInfo*                 pAllocateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkDeviceMemory*                             pMemory);

device is the logical device that owns the memory.
pAllocateInfo is a pointer to a 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 as described in the Memory Allocation chapter.
pMemory is a pointer to a VkDeviceMemory handle in which information about the allocated memory is returned.

Allocations returned by vkAllocateMemory are guaranteed to meet any alignment requirement of 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 with the following constraint:

The contents of unprotected memory must not be a function of data protected memory objects, even if those memory objects were previously freed.

Note

The contents of memory allocated by one application should not be a function of data from protected memory objects of another application, even if those memory objects were previously freed.

The maximum number of valid memory allocations that can exist simultaneously within a VkDevice may be restricted by implementation- or platform-dependent limits. If a call to vkAllocateMemory would cause the total number of allocations to exceed these limits, such a call will fail and must return VK_ERROR_TOO_MANY_OBJECTS. The maxMemoryAllocationCount feature describes the number of allocations that can exist simultaneously before encountering these internal limits.

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 VK_ERROR_OUT_OF_DEVICE_MEMORY must be returned. This limit is advertised in VkPhysicalDeviceMaintenance3Properties::maxMemoryAllocationSize.

The cumulative memory size allocated to a heap can be limited by the size of the specified heap. In such cases, allocated memory is tracked on a per-device and per-heap basis. Some platforms allow overallocation into other heaps. The overallocation behavior can be specified through the VK_AMD_memory_overallocation_behavior extension.

Valid Usage

VUID-vkAllocateMemory-pAllocateInfo-01713
pAllocateInfo->allocationSize must be less than or equal to VkPhysicalDeviceMemoryProperties::memoryHeaps[memindex].size where memindex = VkPhysicalDeviceMemoryProperties::memoryTypes[pAllocateInfo->memoryTypeIndex].heapIndex as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from.
VUID-vkAllocateMemory-pAllocateInfo-01714
pAllocateInfo->memoryTypeIndex must be less than VkPhysicalDeviceMemoryProperties::memoryTypeCount as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from.
VUID-vkAllocateMemory-deviceCoherentMemory-02790
If the deviceCoherentMemory feature is not enabled, pAllocateInfo->memoryTypeIndex must not identify a memory type supporting VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD

Valid Usage (Implicit)

VUID-vkAllocateMemory-device-parameter
device must be a valid VkDevice handle
VUID-vkAllocateMemory-pAllocateInfo-parameter
pAllocateInfo must be a valid pointer to a valid VkMemoryAllocateInfo structure
VUID-vkAllocateMemory-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkAllocateMemory-pMemory-parameter
pMemory must be a valid pointer to a VkDeviceMemory handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_INVALID_EXTERNAL_HANDLE
VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR

The VkMemoryAllocateInfo structure is defined as:

typedef struct VkMemoryAllocateInfo {
    VkStructureType    sType;
    const void*        pNext;
    VkDeviceSize       allocationSize;
    uint32_t           memoryTypeIndex;
} VkMemoryAllocateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
allocationSize is the size of the allocation in bytes
memoryTypeIndex is an index identifying a memory type from the memoryTypes array of the VkPhysicalDeviceMemoryProperties structure

A VkMemoryAllocateInfo structure defines a memory import operation if its pNext chain includes one of the following structures:

VkImportMemoryWin32HandleInfoKHR with non-zero handleType value
VkImportMemoryFdInfoKHR with a non-zero handleType value
VkImportMemoryHostPointerInfoEXT with a non-zero handleType value
VkImportAndroidHardwareBufferInfoANDROID with a non-NULL buffer value

Importing memory must not modify the content of the memory. Implementations must ensure that importing memory does not enable the importing Vulkan instance to access any memory or resources in other Vulkan instances other than that corresponding to the memory object imported. Implementations must also ensure accessing imported memory which has not been initialized does not allow the importing Vulkan instance to obtain data from the exporting Vulkan instance or vice-versa.

Note

How exported and imported memory is isolated is left to the implementation, but applications should be aware that such isolation may prevent implementations from placing multiple exportable memory objects in the same physical or virtual page. Hence, applications should avoid creating many small external memory objects whenever possible.

When performing a memory import operation, it is the responsibility of the application to ensure the external handles meet all valid usage requirements. However, implementations must perform sufficient validation of external handles to ensure that the operation results in a valid memory object which will not cause program termination, device loss, queue stalls, or corruption of other resources when used as allowed according to its allocation parameters. If the external handle provided does not meet these requirements, the implementation must fail the memory import operation with the error code VK_ERROR_INVALID_EXTERNAL_HANDLE.

Valid Usage

VUID-VkMemoryAllocateInfo-pNext-00639
If the pNext chain includes a VkExportMemoryAllocateInfo structure, and any of the handle types specified in VkExportMemoryAllocateInfo::handleTypes require a dedicated allocation, as reported by vkGetPhysicalDeviceImageFormatProperties2 in VkExternalImageFormatProperties::externalMemoryProperties.externalMemoryFeatures or VkExternalBufferProperties::externalMemoryProperties.externalMemoryFeatures, the pNext chain must include a VkMemoryDedicatedAllocateInfo or VkDedicatedAllocationMemoryAllocateInfoNV structure with either its image or buffer member set to a value other than VK_NULL_HANDLE.
VUID-VkMemoryAllocateInfo-pNext-00640
If the pNext chain includes a VkExportMemoryAllocateInfo structure, it must not include a VkExportMemoryAllocateInfoNV or VkExportMemoryWin32HandleInfoNV structure.
VUID-VkMemoryAllocateInfo-pNext-00641
If the pNext chain includes a VkImportMemoryWin32HandleInfoKHR structure, it must not include a VkImportMemoryWin32HandleInfoNV structure.
VUID-VkMemoryAllocateInfo-allocationSize-01742
If the parameters define an import operation, the external handle specified was created by the Vulkan API, and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, then the values of allocationSize and memoryTypeIndex must match those specified when the memory object being imported was created.
VUID-VkMemoryAllocateInfo-None-00643
If the parameters define an import operation and the external handle specified was created by the Vulkan API, the device mask specified by VkMemoryAllocateFlagsInfo must match that specified when the memory object being imported was allocated.
VUID-VkMemoryAllocateInfo-None-00644
If the parameters define an import operation and the external handle specified was created by the Vulkan API, the list of physical devices that comprise the logical device passed to vkAllocateMemory must match the list of physical devices that comprise the logical device on which the memory was originally allocated.
VUID-VkMemoryAllocateInfo-memoryTypeIndex-00645
If the parameters define an import operation and the external handle is an NT handle or a global share handle created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryWin32HandlePropertiesKHR.
VUID-VkMemoryAllocateInfo-allocationSize-01743
If the parameters define an import operation, the external handle was created by the Vulkan API, and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR or VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, then the values of allocationSize and memoryTypeIndex must match those specified when the memory object being imported was created.
VUID-VkMemoryAllocateInfo-allocationSize-00646
If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, allocationSize must match the size reported in the memory requirements of the image or buffer member of the VkDedicatedAllocationMemoryAllocateInfoNV structure included in the pNext chain.
VUID-VkMemoryAllocateInfo-allocationSize-00647
If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, allocationSize must match the size specified when creating the Direct3D 12 heap from which the external handle was extracted.
VUID-VkMemoryAllocateInfo-memoryTypeIndex-00648
If the parameters define an import operation and the external handle is a POSIX file descriptor created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryFdPropertiesKHR.
VUID-VkMemoryAllocateInfo-memoryTypeIndex-01872
If the protected memory feature is not enabled, the VkMemoryAllocateInfo::memoryTypeIndex must not indicate a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT.
VUID-VkMemoryAllocateInfo-memoryTypeIndex-01744
If the parameters define an import operation and the external handle is a host pointer, the value of memoryTypeIndex must be one of those returned by vkGetMemoryHostPointerPropertiesEXT
VUID-VkMemoryAllocateInfo-allocationSize-01745
If the parameters define an import operation and the external handle is a host pointer, allocationSize must be an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment
VUID-VkMemoryAllocateInfo-pNext-02805
If the parameters define an import operation and the external handle is a host pointer, the pNext chain must not include a VkDedicatedAllocationMemoryAllocateInfoNV structure with either its image or buffer field set to a value other than VK_NULL_HANDLE.
VUID-VkMemoryAllocateInfo-pNext-02806
If the parameters define an import operation and the external handle is a host pointer, the pNext chain must not include a VkMemoryDedicatedAllocateInfo structure with either its image or buffer field set to a value other than VK_NULL_HANDLE.
VUID-VkMemoryAllocateInfo-allocationSize-02383
If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, allocationSize must be the size returned by vkGetAndroidHardwareBufferPropertiesANDROID for the Android hardware buffer.
VUID-VkMemoryAllocateInfo-pNext-02384
If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, and the pNext chain does not include a VkMemoryDedicatedAllocateInfo structure or VkMemoryDedicatedAllocateInfo::image is VK_NULL_HANDLE, the Android hardware buffer must have a AHardwareBuffer_Desc::format of AHARDWAREBUFFER_FORMAT_BLOB and a AHardwareBuffer_Desc::usage that includes AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER.
VUID-VkMemoryAllocateInfo-memoryTypeIndex-02385
If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, memoryTypeIndex must be one of those returned by vkGetAndroidHardwareBufferPropertiesANDROID for the Android hardware buffer.
VUID-VkMemoryAllocateInfo-pNext-01874
If the parameters do not define an import operation, and the pNext chain includes a VkExportMemoryAllocateInfo structure with VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID included in its handleTypes member, and the pNext chain includes a VkMemoryDedicatedAllocateInfo structure with image not equal to VK_NULL_HANDLE, then allocationSize must be 0, otherwise allocationSize must be greater than 0.
VUID-VkMemoryAllocateInfo-pNext-02386
If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes a VkMemoryDedicatedAllocateInfo with image that is not VK_NULL_HANDLE, the Android hardware buffer’s AHardwareBuffer::usage must include at least one of AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT or AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE.
VUID-VkMemoryAllocateInfo-pNext-02387
If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes a VkMemoryDedicatedAllocateInfo with image that is not VK_NULL_HANDLE, the format of image must be VK_FORMAT_UNDEFINED or the format returned by vkGetAndroidHardwareBufferPropertiesANDROID in VkAndroidHardwareBufferFormatPropertiesANDROID::format for the Android hardware buffer.
VUID-VkMemoryAllocateInfo-pNext-02388
If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes a VkMemoryDedicatedAllocateInfo structure with image that is not VK_NULL_HANDLE, the width, height, and array layer dimensions of image and the Android hardware buffer’s AHardwareBuffer_Desc must be identical.
VUID-VkMemoryAllocateInfo-pNext-02389
If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes a VkMemoryDedicatedAllocateInfo structure with image that is not VK_NULL_HANDLE, and the Android hardware buffer’s AHardwareBuffer::usage includes AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE, the image must have a complete mipmap chain.
VUID-VkMemoryAllocateInfo-pNext-02586
If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes a VkMemoryDedicatedAllocateInfo structure with image that is not VK_NULL_HANDLE, and the Android hardware buffer’s AHardwareBuffer::usage does not include AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE, the image must have exactly one mipmap level.
VUID-VkMemoryAllocateInfo-pNext-02390
If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes a VkMemoryDedicatedAllocateInfo structure with image that is not VK_NULL_HANDLE, each bit set in the usage of image must be listed in AHardwareBuffer Usage Equivalence, and if there is a corresponding AHARDWAREBUFFER_USAGE bit listed that bit must be included in the Android hardware buffer’s AHardwareBuffer_Desc::usage.
VUID-VkMemoryAllocateInfo-opaqueCaptureAddress-03329
If VkMemoryOpaqueCaptureAddressAllocateInfo::opaqueCaptureAddress is not zero, VkMemoryAllocateFlagsInfo::flags must include VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT
VUID-VkMemoryAllocateInfo-flags-03330
If VkMemoryAllocateFlagsInfo::flags includes VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, the bufferDeviceAddressCaptureReplay feature must be enabled
VUID-VkMemoryAllocateInfo-flags-03331
If VkMemoryAllocateFlagsInfo::flags includes VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, the bufferDeviceAddress feature must be enabled
VUID-VkMemoryAllocateInfo-pNext-03332
If the pNext chain includes a VkImportMemoryHostPointerInfoEXT structure, VkMemoryOpaqueCaptureAddressAllocateInfo::opaqueCaptureAddress must be zero
VUID-VkMemoryAllocateInfo-opaqueCaptureAddress-03333
If the parameters define an import operation, VkMemoryOpaqueCaptureAddressAllocateInfo::opaqueCaptureAddress must be zero

Valid Usage (Implicit)

VUID-VkMemoryAllocateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO
VUID-VkMemoryAllocateInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationMemoryAllocateInfoNV, VkExportMemoryAllocateInfo, VkExportMemoryAllocateInfoNV, VkExportMemoryWin32HandleInfoKHR, VkExportMemoryWin32HandleInfoNV, VkImportAndroidHardwareBufferInfoANDROID, VkImportMemoryFdInfoKHR, VkImportMemoryHostPointerInfoEXT, VkImportMemoryWin32HandleInfoKHR, VkImportMemoryWin32HandleInfoNV, VkMemoryAllocateFlagsInfo, VkMemoryDedicatedAllocateInfo, VkMemoryOpaqueCaptureAddressAllocateInfo, or VkMemoryPriorityAllocateInfoEXT
VUID-VkMemoryAllocateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique

If the pNext chain includes a VkMemoryDedicatedAllocateInfo structure, then that structure includes a handle of the sole buffer or image resource that the memory can be bound to.

The VkMemoryDedicatedAllocateInfo structure is defined as:

typedef struct VkMemoryDedicatedAllocateInfo {
    VkStructureType    sType;
    const void*        pNext;
    VkImage            image;
    VkBuffer           buffer;
} VkMemoryDedicatedAllocateInfo;

or the equivalent

typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
image is VK_NULL_HANDLE or a handle of an image which this memory will be bound to.
buffer is VK_NULL_HANDLE or a handle of a buffer which this memory will be bound to.

Valid Usage

VUID-VkMemoryDedicatedAllocateInfo-image-01432
At least one of image and buffer must be VK_NULL_HANDLE
VUID-VkMemoryDedicatedAllocateInfo-image-01433
If image is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the image
VUID-VkMemoryDedicatedAllocateInfo-image-01434
If image is not VK_NULL_HANDLE, image must have been created without VK_IMAGE_CREATE_SPARSE_BINDING_BIT set in VkImageCreateInfo::flags
VUID-VkMemoryDedicatedAllocateInfo-buffer-01435
If buffer is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the buffer
VUID-VkMemoryDedicatedAllocateInfo-buffer-01436
If buffer is not VK_NULL_HANDLE, buffer must have been created without VK_BUFFER_CREATE_SPARSE_BINDING_BIT set in VkBufferCreateInfo::flags
VUID-VkMemoryDedicatedAllocateInfo-image-01876
If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, and the external handle was created by the Vulkan API, then the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory.
VUID-VkMemoryDedicatedAllocateInfo-buffer-01877
If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, and the external handle was created by the Vulkan API, then the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory.
VUID-VkMemoryDedicatedAllocateInfo-image-01878
If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory.
VUID-VkMemoryDedicatedAllocateInfo-buffer-01879
If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory.
VUID-VkMemoryDedicatedAllocateInfo-image-01797
If image is not VK_NULL_HANDLE, image must not have been created with VK_IMAGE_CREATE_DISJOINT_BIT set in VkImageCreateInfo::flags

Valid Usage (Implicit)

VUID-VkMemoryDedicatedAllocateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO
VUID-VkMemoryDedicatedAllocateInfo-image-parameter
If image is not VK_NULL_HANDLE, image must be a valid VkImage handle
VUID-VkMemoryDedicatedAllocateInfo-buffer-parameter
If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle
VUID-VkMemoryDedicatedAllocateInfo-commonparent
Both of buffer, and image that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

If the pNext chain includes a VkDedicatedAllocationMemoryAllocateInfoNV structure, then that structure includes a handle of the sole buffer or image resource that the memory can be bound to.

The VkDedicatedAllocationMemoryAllocateInfoNV structure is defined as:

typedef struct VkDedicatedAllocationMemoryAllocateInfoNV {
    VkStructureType    sType;
    const void*        pNext;
    VkImage            image;
    VkBuffer           buffer;
} VkDedicatedAllocationMemoryAllocateInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
image is VK_NULL_HANDLE or a handle of an image which this memory will be bound to.
buffer is VK_NULL_HANDLE or a handle of a buffer which this memory will be bound to.

Valid Usage

VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00649
At least one of image and buffer must be VK_NULL_HANDLE
VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00650
If image is not VK_NULL_HANDLE, the image must have been created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE
VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00651
If buffer is not VK_NULL_HANDLE, the buffer must have been created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE
VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00652
If image is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the image
VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00653
If buffer is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the buffer
VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00654
If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory.
VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00655
If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory.

Valid Usage (Implicit)

VUID-VkDedicatedAllocationMemoryAllocateInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV
VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-parameter
If image is not VK_NULL_HANDLE, image must be a valid VkImage handle
VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-parameter
If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle
VUID-VkDedicatedAllocationMemoryAllocateInfoNV-commonparent
Both of buffer, and image that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

If the pNext chain includes a VkMemoryPriorityAllocateInfoEXT structure, then that structure includes a priority for the memory.

The VkMemoryPriorityAllocateInfoEXT structure is defined as:

typedef struct VkMemoryPriorityAllocateInfoEXT {
    VkStructureType    sType;
    const void*        pNext;
    float              priority;
} VkMemoryPriorityAllocateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
priority is a floating-point value between 0 and 1, indicating the priority of the allocation relative to other memory allocations. Larger values are higher priority. The granularity of the priorities is implementation-dependent.

Memory allocations with higher priority may be more likely to stay in device-local memory when the system is under memory pressure.

If this structure is not included, it is as if the priority value were 0.5.

Valid Usage

VUID-VkMemoryPriorityAllocateInfoEXT-priority-02602
priority must be between 0 and 1, inclusive

Valid Usage (Implicit)

VUID-VkMemoryPriorityAllocateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT

When allocating memory that may be exported to another process or Vulkan instance, add a VkExportMemoryAllocateInfo structure to the pNext chain of the VkMemoryAllocateInfo structure, specifying the handle types that may be exported.

The VkExportMemoryAllocateInfo structure is defined as:

typedef struct VkExportMemoryAllocateInfo {
    VkStructureType                    sType;
    const void*                        pNext;
    VkExternalMemoryHandleTypeFlags    handleTypes;
} VkExportMemoryAllocateInfo;

or the equivalent

typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
handleTypes is a bitmask of VkExternalMemoryHandleTypeFlagBits specifying one or more memory handle types the application can export from the resulting allocation. The application can request multiple handle types for the same allocation.

Valid Usage

VUID-VkExportMemoryAllocateInfo-handleTypes-00656
The bits in handleTypes must be supported and compatible, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties.

Valid Usage (Implicit)

VUID-VkExportMemoryAllocateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO
VUID-VkExportMemoryAllocateInfo-handleTypes-parameter
handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values

To specify additional attributes of NT handles exported from a memory object, add a VkExportMemoryWin32HandleInfoKHR structure to the pNext chain of the VkMemoryAllocateInfo structure. The VkExportMemoryWin32HandleInfoKHR structure is defined as:

typedef struct VkExportMemoryWin32HandleInfoKHR {
    VkStructureType               sType;
    const void*                   pNext;
    const SECURITY_ATTRIBUTES*    pAttributes;
    DWORD                         dwAccess;
    LPCWSTR                       name;
} VkExportMemoryWin32HandleInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
pAttributes is a pointer to a Windows SECURITY_ATTRIBUTES structure specifying security attributes of the handle.
dwAccess is a DWORD specifying access rights of the handle.
name is a null-terminated UTF-16 string to associate with the underlying resource referenced by NT handles exported from the created memory.

For handles of the following types:

VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT

The implementation must ensure the access rights allow read and write access to the memory.

For handles of the following types:

VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT

The access rights must be:

GENERIC_ALL

1: https://docs.microsoft.com/en-us/windows/win32/sync/synchronization-object-security-and-access-rights

Valid Usage

VUID-VkExportMemoryWin32HandleInfoKHR-handleTypes-00657
If VkExportMemoryAllocateInfo::handleTypes does not include VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, a VkExportMemoryWin32HandleInfoKHR structure must not be included in the pNext chain of VkMemoryAllocateInfo.

Valid Usage (Implicit)

VUID-VkExportMemoryWin32HandleInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR
VUID-VkExportMemoryWin32HandleInfoKHR-pAttributes-parameter
If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value

To import memory from a Windows handle, add a VkImportMemoryWin32HandleInfoKHR structure to the pNext chain of the VkMemoryAllocateInfo structure.

The VkImportMemoryWin32HandleInfoKHR structure is defined as:

typedef struct VkImportMemoryWin32HandleInfoKHR {
    VkStructureType                       sType;
    const void*                           pNext;
    VkExternalMemoryHandleTypeFlagBits    handleType;
    HANDLE                                handle;
    LPCWSTR                               name;
} VkImportMemoryWin32HandleInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
handleType specifies the type of handle or name.
handle is the external handle to import, or NULL.
name is a null-terminated UTF-16 string naming the underlying memory resource to import, or NULL.

Importing memory objects from Windows handles does not transfer ownership of the handle to the Vulkan implementation. For handle types defined as NT handles, the application must release ownership using the CloseHandle system call when the handle is no longer needed.

Applications can import the same underlying memory into multiple instances of Vulkan, into the same instance from which it was exported, and multiple times into a given Vulkan instance. In all cases, each import operation must create a distinct VkDeviceMemory object.

Valid Usage

VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00658
If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties.
VUID-VkImportMemoryWin32HandleInfoKHR-handle-00659
The memory from which handle was exported, or the memory named by name must have been created on the same underlying physical device as device.
VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00660
If handleType is not 0, it must be defined as an NT handle or a global share handle.
VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01439
If handleType is not VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, name must be NULL.
VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01440
If handleType is not 0 and handle is NULL, name must name a valid memory resource of the type specified by handleType.
VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00661
If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType.
VUID-VkImportMemoryWin32HandleInfoKHR-handle-01441
if handle is not NULL, name must be NULL.
VUID-VkImportMemoryWin32HandleInfoKHR-handle-01518
If handle is not NULL, it must obey any requirements listed for handleType in external memory handle types compatibility.
VUID-VkImportMemoryWin32HandleInfoKHR-name-01519
If name is not NULL, it must obey any requirements listed for handleType in external memory handle types compatibility.

Valid Usage (Implicit)

VUID-VkImportMemoryWin32HandleInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR
VUID-VkImportMemoryWin32HandleInfoKHR-handleType-parameter
If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value

To export a Windows handle representing the underlying resources of a Vulkan device memory object, call:

VkResult vkGetMemoryWin32HandleKHR(
    VkDevice                                    device,
    const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
    HANDLE*                                     pHandle);

device is the logical device that created the device memory being exported.
pGetWin32HandleInfo is a pointer to a VkMemoryGetWin32HandleInfoKHR structure containing parameters of the export operation.
pHandle will return the Windows handle representing the underlying resources of the device memory object.

For handle types defined as NT handles, the handles returned by vkGetMemoryWin32HandleKHR are owned by the application. To avoid leaking resources, the application must release ownership of them using the CloseHandle system call when they are no longer needed.

Valid Usage (Implicit)

VUID-vkGetMemoryWin32HandleKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkGetMemoryWin32HandleKHR-pGetWin32HandleInfo-parameter
pGetWin32HandleInfo must be a valid pointer to a valid VkMemoryGetWin32HandleInfoKHR structure
VUID-vkGetMemoryWin32HandleKHR-pHandle-parameter
pHandle must be a valid pointer to a HANDLE value

Return Codes

VK_SUCCESS

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

The VkMemoryGetWin32HandleInfoKHR structure is defined as:

typedef struct VkMemoryGetWin32HandleInfoKHR {
    VkStructureType                       sType;
    const void*                           pNext;
    VkDeviceMemory                        memory;
    VkExternalMemoryHandleTypeFlagBits    handleType;
} VkMemoryGetWin32HandleInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
memory is the memory object from which the handle will be exported.
handleType is the type of handle requested.

The properties of the handle returned depend on the value of handleType. See VkExternalMemoryHandleTypeFlagBits for a description of the properties of the defined external memory handle types.

Valid Usage

VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00662
handleType must have been included in VkExportMemoryAllocateInfo::handleTypes when memory was created.
VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00663
If handleType is defined as an NT handle, vkGetMemoryWin32HandleKHR must be called no more than once for each valid unique combination of memory and handleType.
VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00664
handleType must be defined as an NT handle or a global share handle.

Valid Usage (Implicit)

VUID-VkMemoryGetWin32HandleInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR
VUID-VkMemoryGetWin32HandleInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkMemoryGetWin32HandleInfoKHR-memory-parameter
memory must be a valid VkDeviceMemory handle
VUID-VkMemoryGetWin32HandleInfoKHR-handleType-parameter
handleType must be a valid VkExternalMemoryHandleTypeFlagBits value

Windows memory handles compatible with Vulkan may also be created by non-Vulkan APIs using methods beyond the scope of this specification. To determine the correct parameters to use when importing such handles, call:

VkResult vkGetMemoryWin32HandlePropertiesKHR(
    VkDevice                                    device,
    VkExternalMemoryHandleTypeFlagBits          handleType,
    HANDLE                                      handle,
    VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);

device is the logical device that will be importing handle.
handleType is the type of the handle handle.
handle is the handle which will be imported.
pMemoryWin32HandleProperties will return properties of handle.

Valid Usage

VUID-vkGetMemoryWin32HandlePropertiesKHR-handle-00665
handle must be an external memory handle created outside of the Vulkan API.
VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-00666
handleType must not be one of the handle types defined as opaque.

Valid Usage (Implicit)

VUID-vkGetMemoryWin32HandlePropertiesKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-parameter
handleType must be a valid VkExternalMemoryHandleTypeFlagBits value
VUID-vkGetMemoryWin32HandlePropertiesKHR-pMemoryWin32HandleProperties-parameter
pMemoryWin32HandleProperties must be a valid pointer to a VkMemoryWin32HandlePropertiesKHR structure

Return Codes

VK_SUCCESS

VK_ERROR_INVALID_EXTERNAL_HANDLE

The VkMemoryWin32HandlePropertiesKHR structure returned is defined as:

typedef struct VkMemoryWin32HandlePropertiesKHR {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           memoryTypeBits;
} VkMemoryWin32HandlePropertiesKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
memoryTypeBits is a bitmask containing one bit set for every memory type which the specified windows handle can be imported as.

Valid Usage (Implicit)

VUID-VkMemoryWin32HandlePropertiesKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR
VUID-VkMemoryWin32HandlePropertiesKHR-pNext-pNext
pNext must be NULL

To import memory from a POSIX file descriptor handle, add a VkImportMemoryFdInfoKHR structure to the pNext chain of the VkMemoryAllocateInfo structure. The VkImportMemoryFdInfoKHR structure is defined as:

typedef struct VkImportMemoryFdInfoKHR {
    VkStructureType                       sType;
    const void*                           pNext;
    VkExternalMemoryHandleTypeFlagBits    handleType;
    int                                   fd;
} VkImportMemoryFdInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
handleType specifies the handle type of fd.
fd is the external handle to import.

Importing memory from a file descriptor transfers ownership of the file descriptor from the application to the Vulkan implementation. The application must not perform any operations on the file descriptor after a successful import.

Valid Usage

VUID-VkImportMemoryFdInfoKHR-handleType-00667
If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties.
VUID-VkImportMemoryFdInfoKHR-fd-00668
The memory from which fd was exported must have been created on the same underlying physical device as device.
VUID-VkImportMemoryFdInfoKHR-handleType-00669
If handleType is not 0, it must be defined as a POSIX file descriptor handle.
VUID-VkImportMemoryFdInfoKHR-handleType-00670
If handleType is not 0, fd must be a valid handle of the type specified by handleType.
VUID-VkImportMemoryFdInfoKHR-fd-01746
The memory represented by fd must have been created from a physical device and driver that is compatible with device and handleType, as described in External memory handle types compatibility.
VUID-VkImportMemoryFdInfoKHR-fd-01520
fd must obey any requirements listed for handleType in external memory handle types compatibility.

Valid Usage (Implicit)

VUID-VkImportMemoryFdInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR
VUID-VkImportMemoryFdInfoKHR-handleType-parameter
If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value

To export a POSIX file descriptor representing the underlying resources of a Vulkan device memory object, call:

VkResult vkGetMemoryFdKHR(
    VkDevice                                    device,
    const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
    int*                                        pFd);

device is the logical device that created the device memory being exported.
pGetFdInfo is a pointer to a VkMemoryGetFdInfoKHR structure containing parameters of the export operation.
pFd will return a file descriptor representing the underlying resources of the device memory object.

Each call to vkGetMemoryFdKHR must create a new file descriptor and transfer ownership of it to the application. To avoid leaking resources, the application must release ownership of the file descriptor using the close system call when it is no longer needed, or by importing a Vulkan memory object from it. Where supported by the operating system, the implementation must set the file descriptor to be closed automatically when an execve system call is made.

Valid Usage (Implicit)

VUID-vkGetMemoryFdKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkGetMemoryFdKHR-pGetFdInfo-parameter
pGetFdInfo must be a valid pointer to a valid VkMemoryGetFdInfoKHR structure
VUID-vkGetMemoryFdKHR-pFd-parameter
pFd must be a valid pointer to an int value

Return Codes

VK_SUCCESS

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

The VkMemoryGetFdInfoKHR structure is defined as:

typedef struct VkMemoryGetFdInfoKHR {
    VkStructureType                       sType;
    const void*                           pNext;
    VkDeviceMemory                        memory;
    VkExternalMemoryHandleTypeFlagBits    handleType;
} VkMemoryGetFdInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
memory is the memory object from which the handle will be exported.
handleType is the type of handle requested.

The properties of the file descriptor exported depend on the value of handleType. See VkExternalMemoryHandleTypeFlagBits for a description of the properties of the defined external memory handle types.

Note

The size of the exported file may be larger than the size requested by VkMemoryAllocateInfo::allocationSize. If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT, then the application can query the file’s actual size with lseek(2).

Valid Usage

VUID-VkMemoryGetFdInfoKHR-handleType-00671
handleType must have been included in VkExportMemoryAllocateInfo::handleTypes when memory was created.
VUID-VkMemoryGetFdInfoKHR-handleType-00672
handleType must be defined as a POSIX file descriptor handle.

Valid Usage (Implicit)

VUID-VkMemoryGetFdInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR
VUID-VkMemoryGetFdInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkMemoryGetFdInfoKHR-memory-parameter
memory must be a valid VkDeviceMemory handle
VUID-VkMemoryGetFdInfoKHR-handleType-parameter
handleType must be a valid VkExternalMemoryHandleTypeFlagBits value

POSIX file descriptor memory handles compatible with Vulkan may also be created by non-Vulkan APIs using methods beyond the scope of this specification. To determine the correct parameters to use when importing such handles, call:

VkResult vkGetMemoryFdPropertiesKHR(
    VkDevice                                    device,
    VkExternalMemoryHandleTypeFlagBits          handleType,
    int                                         fd,
    VkMemoryFdPropertiesKHR*                    pMemoryFdProperties);

device is the logical device that will be importing fd.
handleType is the type of the handle fd.
fd is the handle which will be imported.
pMemoryFdProperties is a pointer to a VkMemoryFdPropertiesKHR structure in which the properties of the handle fd are returned.

Valid Usage

VUID-vkGetMemoryFdPropertiesKHR-fd-00673
fd must be an external memory handle created outside of the Vulkan API.
VUID-vkGetMemoryFdPropertiesKHR-handleType-00674
handleType must not be VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR.

Valid Usage (Implicit)

VUID-vkGetMemoryFdPropertiesKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkGetMemoryFdPropertiesKHR-handleType-parameter
handleType must be a valid VkExternalMemoryHandleTypeFlagBits value
VUID-vkGetMemoryFdPropertiesKHR-pMemoryFdProperties-parameter
pMemoryFdProperties must be a valid pointer to a VkMemoryFdPropertiesKHR structure

Return Codes

VK_SUCCESS

VK_ERROR_INVALID_EXTERNAL_HANDLE

The VkMemoryFdPropertiesKHR structure returned is defined as:

typedef struct VkMemoryFdPropertiesKHR {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           memoryTypeBits;
} VkMemoryFdPropertiesKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
memoryTypeBits is a bitmask containing one bit set for every memory type which the specified file descriptor can be imported as.

Valid Usage (Implicit)

VUID-VkMemoryFdPropertiesKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR
VUID-VkMemoryFdPropertiesKHR-pNext-pNext
pNext must be NULL

To import memory from a host pointer, add a VkImportMemoryHostPointerInfoEXT structure to the pNext chain of the VkMemoryAllocateInfo structure. The VkImportMemoryHostPointerInfoEXT structure is defined as:

typedef struct VkImportMemoryHostPointerInfoEXT {
    VkStructureType                       sType;
    const void*                           pNext;
    VkExternalMemoryHandleTypeFlagBits    handleType;
    void*                                 pHostPointer;
} VkImportMemoryHostPointerInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
handleType specifies the handle type.
pHostPointer is the host pointer to import from.

Importing memory from a host pointer shares ownership of the memory between the host and the Vulkan implementation. The application can continue to access the memory through the host pointer but it is the application’s responsibility to synchronize device and non-device access to the underlying memory as defined in Host Access to Device Memory Objects.

Applications can import the same underlying memory into multiple instances of Vulkan and multiple times into a given Vulkan instance. However, implementations may fail to import the same underlying memory multiple times into a given physical device due to platform constraints.

Importing memory from a particular host pointer may not be possible due to additional platform-specific restrictions beyond the scope of this specification in which case the implementation must fail the memory import operation with the error code VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR.

The application must ensure that the imported memory range remains valid and accessible for the lifetime of the imported memory object.

Valid Usage

VUID-VkImportMemoryHostPointerInfoEXT-handleType-01747
If handleType is not 0, it must be supported for import, as reported in VkExternalMemoryProperties
VUID-VkImportMemoryHostPointerInfoEXT-handleType-01748
If handleType is not 0, it must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT
VUID-VkImportMemoryHostPointerInfoEXT-pHostPointer-01749
pHostPointer must be a pointer aligned to an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment
VUID-VkImportMemoryHostPointerInfoEXT-handleType-01750
If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, pHostPointer must be a pointer to allocationSize number of bytes of host memory, where allocationSize is the member of the VkMemoryAllocateInfo structure this structure is chained to
VUID-VkImportMemoryHostPointerInfoEXT-handleType-01751
If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, pHostPointer must be a pointer to allocationSize number of bytes of host mapped foreign memory, where allocationSize is the member of the VkMemoryAllocateInfo structure this structure is chained to

Valid Usage (Implicit)

VUID-VkImportMemoryHostPointerInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT
VUID-VkImportMemoryHostPointerInfoEXT-handleType-parameter
handleType must be a valid VkExternalMemoryHandleTypeFlagBits value

To determine the correct parameters to use when importing host pointers, call:

VkResult vkGetMemoryHostPointerPropertiesEXT(
    VkDevice                                    device,
    VkExternalMemoryHandleTypeFlagBits          handleType,
    const void*                                 pHostPointer,
    VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties);

device is the logical device that will be importing pHostPointer.
handleType is the type of the handle pHostPointer.
pHostPointer is the host pointer to import from.
pMemoryHostPointerProperties is a pointer to a VkMemoryHostPointerPropertiesEXT structure in which the host pointer properties are returned.

Valid Usage

VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01752
handleType must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT
VUID-vkGetMemoryHostPointerPropertiesEXT-pHostPointer-01753
pHostPointer must be a pointer aligned to an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment
VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01754
If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, pHostPointer must be a pointer to host memory
VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01755
If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, pHostPointer must be a pointer to host mapped foreign memory

Valid Usage (Implicit)

VUID-vkGetMemoryHostPointerPropertiesEXT-device-parameter
device must be a valid VkDevice handle
VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-parameter
handleType must be a valid VkExternalMemoryHandleTypeFlagBits value
VUID-vkGetMemoryHostPointerPropertiesEXT-pMemoryHostPointerProperties-parameter
pMemoryHostPointerProperties must be a valid pointer to a VkMemoryHostPointerPropertiesEXT structure

Return Codes

VK_SUCCESS

VK_ERROR_INVALID_EXTERNAL_HANDLE

The VkMemoryHostPointerPropertiesEXT structure is defined as:

typedef struct VkMemoryHostPointerPropertiesEXT {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           memoryTypeBits;
} VkMemoryHostPointerPropertiesEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
memoryTypeBits is a bitmask containing one bit set for every memory type which the specified host pointer can be imported as.

The value returned by memoryTypeBits must only include bits that identify memory types which are host visible.

Valid Usage (Implicit)

VUID-VkMemoryHostPointerPropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT
VUID-VkMemoryHostPointerPropertiesEXT-pNext-pNext
pNext must be NULL

To import memory created outside of the current Vulkan instance from an Android hardware buffer, add a VkImportAndroidHardwareBufferInfoANDROID structure to the pNext chain of the VkMemoryAllocateInfo structure. The VkImportAndroidHardwareBufferInfoANDROID structure is defined as:

typedef struct VkImportAndroidHardwareBufferInfoANDROID {
    VkStructureType            sType;
    const void*                pNext;
    struct AHardwareBuffer*    buffer;
} VkImportAndroidHardwareBufferInfoANDROID;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
buffer is the Android hardware buffer to import.

If the vkAllocateMemory command succeeds, the implementation must acquire a reference to the imported hardware buffer, which it must release when the device memory object is freed. If the command fails, the implementation must not retain a reference.

Valid Usage

VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01880
If buffer is not NULL, Android hardware buffers must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties.
VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01881
If buffer is not NULL, it must be a valid Android hardware buffer object with AHardwareBuffer_Desc::format and AHardwareBuffer_Desc::usage compatible with Vulkan as described in Android Hardware Buffers.

Valid Usage (Implicit)

VUID-VkImportAndroidHardwareBufferInfoANDROID-sType-sType
sType must be VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID
VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-parameter
buffer must be a valid pointer to an AHardwareBuffer value

To export an Android hardware buffer representing the underlying resources of a Vulkan device memory object, call:

VkResult vkGetMemoryAndroidHardwareBufferANDROID(
    VkDevice                                    device,
    const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
    struct AHardwareBuffer**                    pBuffer);

device is the logical device that created the device memory being exported.
pInfo is a pointer to a VkMemoryGetAndroidHardwareBufferInfoANDROID structure containing parameters of the export operation.
pBuffer will return an Android hardware buffer representing the underlying resources of the device memory object.

Each call to vkGetMemoryAndroidHardwareBufferANDROID must return an Android hardware buffer with a new reference acquired in addition to the reference held by the VkDeviceMemory. To avoid leaking resources, the application must release the reference by calling AHardwareBuffer_release when it is no longer needed. When called with the same handle in VkMemoryGetAndroidHardwareBufferInfoANDROID::memory, vkGetMemoryAndroidHardwareBufferANDROID must return the same Android hardware buffer object. If the device memory was created by importing an Android hardware buffer, vkGetMemoryAndroidHardwareBufferANDROID must return that same Android hardware buffer object.

Valid Usage (Implicit)

VUID-vkGetMemoryAndroidHardwareBufferANDROID-device-parameter
device must be a valid VkDevice handle
VUID-vkGetMemoryAndroidHardwareBufferANDROID-pInfo-parameter
pInfo must be a valid pointer to a valid VkMemoryGetAndroidHardwareBufferInfoANDROID structure
VUID-vkGetMemoryAndroidHardwareBufferANDROID-pBuffer-parameter
pBuffer must be a valid pointer to a valid pointer to an AHardwareBuffer value

Return Codes

VK_SUCCESS

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

The VkMemoryGetAndroidHardwareBufferInfoANDROID structure is defined as:

typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID {
    VkStructureType    sType;
    const void*        pNext;
    VkDeviceMemory     memory;
} VkMemoryGetAndroidHardwareBufferInfoANDROID;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
memory is the memory object from which the Android hardware buffer will be exported.

Valid Usage

VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-handleTypes-01882
VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must have been included in VkExportMemoryAllocateInfo::handleTypes when memory was created.
VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-01883
If the pNext chain of the VkMemoryAllocateInfo used to allocate memory included a VkMemoryDedicatedAllocateInfo with non-NULL image member, then that image must already be bound to memory.

Valid Usage (Implicit)

VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-sType-sType
sType must be VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID
VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-pNext
pNext must be NULL
VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-memory-parameter
memory must be a valid VkDeviceMemory handle

To determine the memory parameters to use when importing an Android hardware buffer, call:

VkResult vkGetAndroidHardwareBufferPropertiesANDROID(
    VkDevice                                    device,
    const struct AHardwareBuffer*               buffer,
    VkAndroidHardwareBufferPropertiesANDROID*   pProperties);

device is the logical device that will be importing buffer.
buffer is the Android hardware buffer which will be imported.
pProperties is a pointer to a VkAndroidHardwareBufferPropertiesANDROID structure in which the properties of buffer are returned.

Valid Usage

VUID-vkGetAndroidHardwareBufferPropertiesANDROID-buffer-01884
buffer must be a valid Android hardware buffer object with at least one of the AHARDWAREBUFFER_USAGE_GPU_* flags in its AHardwareBuffer_Desc::usage

Valid Usage (Implicit)

VUID-vkGetAndroidHardwareBufferPropertiesANDROID-device-parameter
device must be a valid VkDevice handle
VUID-vkGetAndroidHardwareBufferPropertiesANDROID-buffer-parameter
buffer must be a valid pointer to a valid AHardwareBuffer value
VUID-vkGetAndroidHardwareBufferPropertiesANDROID-pProperties-parameter
pProperties must be a valid pointer to a VkAndroidHardwareBufferPropertiesANDROID structure

Return Codes

VK_SUCCESS

VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR

The VkAndroidHardwareBufferPropertiesANDROID structure returned is defined as:

typedef struct VkAndroidHardwareBufferPropertiesANDROID {
    VkStructureType    sType;
    void*              pNext;
    VkDeviceSize       allocationSize;
    uint32_t           memoryTypeBits;
} VkAndroidHardwareBufferPropertiesANDROID;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
allocationSize is the size of the external memory
memoryTypeBits is a bitmask containing one bit set for every memory type which the specified Android hardware buffer can be imported as.

Valid Usage (Implicit)

VUID-VkAndroidHardwareBufferPropertiesANDROID-sType-sType
sType must be VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID
VUID-VkAndroidHardwareBufferPropertiesANDROID-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkAndroidHardwareBufferFormatPropertiesANDROID
VUID-VkAndroidHardwareBufferPropertiesANDROID-sType-unique
The sType value of each struct in the pNext chain must be unique

To obtain format properties of an Android hardware buffer, include a VkAndroidHardwareBufferFormatPropertiesANDROID structure in the pNext chain of the VkAndroidHardwareBufferPropertiesANDROID structure passed to vkGetAndroidHardwareBufferPropertiesANDROID. This structure is defined as:

typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID {
    VkStructureType                  sType;
    void*                            pNext;
    VkFormat                         format;
    uint64_t                         externalFormat;
    VkFormatFeatureFlags             formatFeatures;
    VkComponentMapping               samplerYcbcrConversionComponents;
    VkSamplerYcbcrModelConversion    suggestedYcbcrModel;
    VkSamplerYcbcrRange              suggestedYcbcrRange;
    VkChromaLocation                 suggestedXChromaOffset;
    VkChromaLocation                 suggestedYChromaOffset;
} VkAndroidHardwareBufferFormatPropertiesANDROID;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
format is the Vulkan format corresponding to the Android hardware buffer’s format, or VK_FORMAT_UNDEFINED if there is not an equivalent Vulkan format.
externalFormat is an implementation-defined external format identifier for use with VkExternalFormatANDROID. It must not be zero.
formatFeatures describes the capabilities of this external format when used with an image bound to memory imported from buffer.
samplerYcbcrConversionComponents is the component swizzle that should be used in VkSamplerYcbcrConversionCreateInfo.
suggestedYcbcrModel is a suggested color model to use in the VkSamplerYcbcrConversionCreateInfo.
suggestedYcbcrRange is a suggested numerical value range to use in VkSamplerYcbcrConversionCreateInfo.
suggestedXChromaOffset is a suggested X chroma offset to use in VkSamplerYcbcrConversionCreateInfo.
suggestedYChromaOffset is a suggested Y chroma offset to use in VkSamplerYcbcrConversionCreateInfo.

If the Android hardware buffer has one of the formats listed in the Format Equivalence table, then format must have the equivalent Vulkan format listed in the table. Otherwise, format may be VK_FORMAT_UNDEFINED, indicating the Android hardware buffer can only be used with an external format.

The formatFeatures member must include VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT and at least one of VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT or VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, and should include VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT and VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT.

Note

The formatFeatures member only indicates the features available when using an external-format image created from the Android hardware buffer. Images from Android hardware buffers with a format other than VK_FORMAT_UNDEFINED are subject to the format capabilities obtained from vkGetPhysicalDeviceFormatProperties2, and vkGetPhysicalDeviceImageFormatProperties2 with appropriate parameters. These sets of features are independent of each other, e.g. the external format will support sampler Y′C_BC_R conversion even if the non-external format does not, and writing to non-external format images is possible but writing to external format images is not.

Android hardware buffers with the same external format must have the same support for VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, and VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT. in formatFeatures. Other format features may differ between Android hardware buffers that have the same external format. This allows applications to use the same VkSamplerYcbcrConversion object (and samplers and pipelines created from them) for any Android hardware buffers that have the same external format.

If format is not VK_FORMAT_UNDEFINED, then the value of samplerYcbcrConversionComponents must be valid when used as the components member of VkSamplerYcbcrConversionCreateInfo with that format. If format is VK_FORMAT_UNDEFINED, all members of samplerYcbcrConversionComponents must be VK_COMPONENT_SWIZZLE_IDENTITY.

Implementations may not always be able to determine the color model, numerical range, or chroma offsets of the image contents, so the values in VkAndroidHardwareBufferFormatPropertiesANDROID are only suggestions. Applications should treat these values as sensible defaults to use in the absence of more reliable information obtained through some other means. If the underlying physical device is also usable via OpenGL ES with the GL_OES_EGL_image_external extension, the implementation should suggest values that will produce similar sampled values as would be obtained by sampling the same external image via samplerExternalOES in OpenGL ES using equivalent sampler parameters.

Note

Since GL_OES_EGL_image_external does not require the same sampling and conversion calculations as Vulkan does, achieving identical results between APIs may not be possible on some implementations.

Valid Usage (Implicit)

VUID-VkAndroidHardwareBufferFormatPropertiesANDROID-sType-sType
sType must be VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID

When allocating memory that may be exported to another process or Vulkan instance, add a VkExportMemoryAllocateInfoNV structure to the pNext chain of the VkMemoryAllocateInfo structure, specifying the handle types that may be exported.

The VkExportMemoryAllocateInfoNV structure is defined as:

typedef struct VkExportMemoryAllocateInfoNV {
    VkStructureType                      sType;
    const void*                          pNext;
    VkExternalMemoryHandleTypeFlagsNV    handleTypes;
} VkExportMemoryAllocateInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
handleTypes is a bitmask of VkExternalMemoryHandleTypeFlagBitsNV specifying one or more memory handle types that may be exported. Multiple handle types may be requested for the same allocation as long as they are compatible, as reported by vkGetPhysicalDeviceExternalImageFormatPropertiesNV.

Valid Usage (Implicit)

VUID-VkExportMemoryAllocateInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV
VUID-VkExportMemoryAllocateInfoNV-handleTypes-parameter
handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values

When VkExportMemoryAllocateInfoNV::handleTypes includes VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV, add a VkExportMemoryWin32HandleInfoNV structure to the pNext chain of the VkExportMemoryAllocateInfoNV structure to specify security attributes and access rights for the memory object’s external handle.

The VkExportMemoryWin32HandleInfoNV structure is defined as:

typedef struct VkExportMemoryWin32HandleInfoNV {
    VkStructureType               sType;
    const void*                   pNext;
    const SECURITY_ATTRIBUTES*    pAttributes;
    DWORD                         dwAccess;
} VkExportMemoryWin32HandleInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
pAttributes is a pointer to a Windows SECURITY_ATTRIBUTES structure specifying security attributes of the handle.
dwAccess is a DWORD specifying access rights of the handle.

DXGI_SHARED_RESOURCE_READ | DXGI_SHARED_RESOURCE_WRITE

1: https://docs.microsoft.com/en-us/windows/win32/sync/synchronization-object-security-and-access-rights

Valid Usage (Implicit)

VUID-VkExportMemoryWin32HandleInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV
VUID-VkExportMemoryWin32HandleInfoNV-pAttributes-parameter
If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value

To import memory created on the same physical device but outside of the current Vulkan instance, add a VkImportMemoryWin32HandleInfoNV structure to the pNext chain of the VkMemoryAllocateInfo structure, specifying a handle to and the type of the memory.

The VkImportMemoryWin32HandleInfoNV structure is defined as:

typedef struct VkImportMemoryWin32HandleInfoNV {
    VkStructureType                      sType;
    const void*                          pNext;
    VkExternalMemoryHandleTypeFlagsNV    handleType;
    HANDLE                               handle;
} VkImportMemoryWin32HandleInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
handleType is 0 or a VkExternalMemoryHandleTypeFlagBitsNV value specifying the type of memory handle in handle.
handle is a Windows HANDLE referring to the memory.

If handleType is 0, this structure is ignored by consumers of the VkMemoryAllocateInfo structure it is chained from.

Valid Usage

VUID-VkImportMemoryWin32HandleInfoNV-handleType-01327
handleType must not have more than one bit set.
VUID-VkImportMemoryWin32HandleInfoNV-handle-01328
handle must be a valid handle to memory, obtained as specified by handleType.

Valid Usage (Implicit)

VUID-VkImportMemoryWin32HandleInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV
VUID-VkImportMemoryWin32HandleInfoNV-handleType-parameter
handleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values

Bits which can be set in handleType are:

Possible values of VkImportMemoryWin32HandleInfoNV::handleType, specifying the type of an external memory handle, are:

typedef enum VkExternalMemoryHandleTypeFlagBitsNV {
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
} VkExternalMemoryHandleTypeFlagBitsNV;

VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV specifies a handle to memory returned by vkGetMemoryWin32HandleNV.
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV specifies a handle to memory returned by vkGetMemoryWin32HandleNV, or one duplicated from such a handle using DuplicateHandle().
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV specifies a valid NT handle to memory returned by IDXGIResource1::CreateSharedHandle, or a handle duplicated from such a handle using DuplicateHandle().
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV specifies a handle to memory returned by IDXGIResource::GetSharedHandle().

editing-note

(Jon) If additional (non-Win32) bits are added to the possible memory types, this type should move to the [VK_NV_external_memory_capabilities] section, and each bit would then be protected by ifdefs for the extension it’s defined by.

typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;

VkExternalMemoryHandleTypeFlagsNV is a bitmask type for setting a mask of zero or more VkExternalMemoryHandleTypeFlagBitsNV.

To retrieve the handle corresponding to a device memory object created with VkExportMemoryAllocateInfoNV::handleTypes set to include VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV or VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV, call:

VkResult vkGetMemoryWin32HandleNV(
    VkDevice                                    device,
    VkDeviceMemory                              memory,
    VkExternalMemoryHandleTypeFlagsNV           handleType,
    HANDLE*                                     pHandle);

device is the logical device that owns the memory.
memory is the VkDeviceMemory object.
handleType is a bitmask of VkExternalMemoryHandleTypeFlagBitsNV containing a single bit specifying the type of handle requested.
handle is a pointer to a Windows HANDLE in which the handle is returned.

Valid Usage

VUID-vkGetMemoryWin32HandleNV-handleType-01326
handleType must be a flag specified in VkExportMemoryAllocateInfoNV::handleTypes when allocating memory

Valid Usage (Implicit)

VUID-vkGetMemoryWin32HandleNV-device-parameter
device must be a valid VkDevice handle
VUID-vkGetMemoryWin32HandleNV-memory-parameter
memory must be a valid VkDeviceMemory handle
VUID-vkGetMemoryWin32HandleNV-handleType-parameter
handleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values
VUID-vkGetMemoryWin32HandleNV-handleType-requiredbitmask
handleType must not be 0
VUID-vkGetMemoryWin32HandleNV-pHandle-parameter
pHandle must be a valid pointer to a HANDLE value
VUID-vkGetMemoryWin32HandleNV-memory-parent
memory must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

If the pNext chain of VkMemoryAllocateInfo includes a VkMemoryAllocateFlagsInfo structure, then that structure includes flags and a device mask controlling how many instances of the memory will be allocated.

The VkMemoryAllocateFlagsInfo structure is defined as:

typedef struct VkMemoryAllocateFlagsInfo {
    VkStructureType          sType;
    const void*              pNext;
    VkMemoryAllocateFlags    flags;
    uint32_t                 deviceMask;
} VkMemoryAllocateFlagsInfo;

or the equivalent

typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkMemoryAllocateFlagBits controlling the allocation.
deviceMask is a mask of physical devices in the logical device, indicating that memory must be allocated on each device in the mask, if VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT is set in flags.

If VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT is not set, the number of instances allocated depends on whether VK_MEMORY_HEAP_MULTI_INSTANCE_BIT is set in the memory heap. If VK_MEMORY_HEAP_MULTI_INSTANCE_BIT is set, then memory is allocated for every physical device in the logical device (as if deviceMask has bits set for all device indices). If VK_MEMORY_HEAP_MULTI_INSTANCE_BIT is not set, then a single instance of memory is allocated (as if deviceMask is set to one).

On some implementations, allocations from a multi-instance heap may consume memory on all physical devices even if the deviceMask excludes some devices. If VkPhysicalDeviceGroupProperties::subsetAllocation is VK_TRUE, then memory is only consumed for the devices in the device mask.

Note

In practice, most allocations on a multi-instance heap will be allocated across all physical devices. Unicast allocation support is an optional optimization for a minority of allocations.

Valid Usage

VUID-VkMemoryAllocateFlagsInfo-deviceMask-00675
If VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT is set, deviceMask must be a valid device mask.
VUID-VkMemoryAllocateFlagsInfo-deviceMask-00676
If VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT is set, deviceMask must not be zero

Valid Usage (Implicit)

VUID-VkMemoryAllocateFlagsInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO
VUID-VkMemoryAllocateFlagsInfo-flags-parameter
flags must be a valid combination of VkMemoryAllocateFlagBits values

Bits which can be set in VkMemoryAllocateFlagsInfo::flags, controlling device memory allocation, are:

typedef enum VkMemoryAllocateFlagBits {
    VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001,
    VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 0x00000002,
    VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000004,
    VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
    VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
    VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
    VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkMemoryAllocateFlagBits;

or the equivalent

typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR;

VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT specifies that memory will be allocated for the devices in VkMemoryAllocateFlagsInfo::deviceMask.
VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT specifies that the memory can be attached to a buffer object created with the VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT bit set in usage, and that the memory handle can be used to retrieve an opaque address via vkGetDeviceMemoryOpaqueCaptureAddress.
VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT specifies that the memory’s address can be saved and reused on a subsequent run (e.g. for trace capture and replay), see VkBufferOpaqueCaptureAddressCreateInfo for more detail.

typedef VkFlags VkMemoryAllocateFlags;

or the equivalent

typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR;

VkMemoryAllocateFlags is a bitmask type for setting a mask of zero or more VkMemoryAllocateFlagBits.

To request a specific device address for a memory allocation, add a VkMemoryOpaqueCaptureAddressAllocateInfo structure to the pNext chain of the VkMemoryAllocateInfo structure. The VkMemoryOpaqueCaptureAddressAllocateInfo structure is defined as:

typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo {
    VkStructureType    sType;
    const void*        pNext;
    uint64_t           opaqueCaptureAddress;
} VkMemoryOpaqueCaptureAddressAllocateInfo;

or the equivalent

typedef VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
opaqueCaptureAddress is the opaque capture address requested for the memory allocation.

If opaqueCaptureAddress is zero, no specific address is requested.

If opaqueCaptureAddress is not zero, it should be an address retrieved from vkGetDeviceMemoryOpaqueCaptureAddress on an identically created memory allocation on the same implementation.

Note

In most cases, it is expected that a non-zero opaqueAddress is an address retrieved from vkGetDeviceMemoryOpaqueCaptureAddress on an identically created memory allocation. If this is not the case, it likely that VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS errors will occur.

This is, however, not a strict requirement because trace capture/replay tools may need to adjust memory allocation parameters for imported memory.

If this structure is not present, it is as if opaqueCaptureAddress is zero.

Valid Usage (Implicit)

VUID-VkMemoryOpaqueCaptureAddressAllocateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO

To free a memory object, call:

void vkFreeMemory(
    VkDevice                                    device,
    VkDeviceMemory                              memory,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that owns the memory.
memory is the VkDeviceMemory object to be freed.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

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 in the pending state. Memory can be freed whilst still bound to resources, but those resources must not be used afterwards. 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.

How memory objects are bound to Images and Buffers is described in detail in the Resource Memory Association section.

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

Note

As described below, host writes are not implicitly flushed when the memory object is unmapped, but the implementation must guarantee that writes that have not been flushed do not affect any other memory.

Valid Usage

VUID-vkFreeMemory-memory-00677
All submitted commands that refer to memory (via images or buffers) must have completed execution

Valid Usage (Implicit)

VUID-vkFreeMemory-device-parameter
device must be a valid VkDevice handle
VUID-vkFreeMemory-memory-parameter
If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle
VUID-vkFreeMemory-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkFreeMemory-memory-parent
If memory is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to memory must be externally synchronized

10.2.1. Host Access to Device Memory Objects

Memory objects created with vkAllocateMemory are not directly host accessible.

Memory objects created with the memory property VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT are considered mappable. Memory objects must be mappable in order to be successfully mapped on the host.

To retrieve a host virtual address pointer to a region of a mappable memory object, call:

VkResult vkMapMemory(
    VkDevice                                    device,
    VkDeviceMemory                              memory,
    VkDeviceSize                                offset,
    VkDeviceSize                                size,
    VkMemoryMapFlags                            flags,
    void**                                      ppData);

device is the logical device that owns the memory.
memory is the VkDeviceMemory object to be mapped.
offset is a zero-based byte offset from the beginning of the memory object.
size is the size of the memory range to map, or VK_WHOLE_SIZE to map from offset to the end of the allocation.
flags is reserved for future use.
ppData is a pointer to a void * variable 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.

After a successful call to vkMapMemory the memory object memory is considered to be currently host mapped.

Note

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

Note

vkMapMemory will fail if the implementation is unable to allocate an appropriately sized contiguous virtual address range, e.g. due to virtual address space fragmentation or platform limits. In such cases, vkMapMemory must return VK_ERROR_MEMORY_MAP_FAILED. The application can improve the likelihood of success by reducing the size of the mapped range and/or removing unneeded mappings using vkUnmapMemory.

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 (see here for details on fulfilling such a guarantee). If the device memory was allocated without the VK_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 host mapped, the application is responsible for synchronizing both device and host access to that memory range.

Note

It is important for the application developer to become meticulously familiar with all of the mechanisms described in the chapter on Synchronization and Cache Control as they are crucial to maintaining memory access ordering.

Valid Usage

VUID-vkMapMemory-memory-00678
memory must not be currently host mapped
VUID-vkMapMemory-offset-00679
offset must be less than the size of memory
VUID-vkMapMemory-size-00680
If size is not equal to VK_WHOLE_SIZE, size must be greater than 0
VUID-vkMapMemory-size-00681
If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to the size of the memory minus offset
VUID-vkMapMemory-memory-00682
memory must have been created with a memory type that reports VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
VUID-vkMapMemory-memory-00683
memory must not have been allocated with multiple instances.

Valid Usage (Implicit)

VUID-vkMapMemory-device-parameter
device must be a valid VkDevice handle
VUID-vkMapMemory-memory-parameter
memory must be a valid VkDeviceMemory handle
VUID-vkMapMemory-flags-zerobitmask
flags must be 0
VUID-vkMapMemory-ppData-parameter
ppData must be a valid pointer to a pointer value
VUID-vkMapMemory-memory-parent
memory must have been created, allocated, or retrieved from device

Host Synchronization

Host access to memory must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_MEMORY_MAP_FAILED

typedef VkFlags VkMemoryMapFlags;

VkMemoryMapFlags is a bitmask type for setting a mask, but is currently reserved for future use.

Two commands are provided to enable applications to work with non-coherent memory allocations: vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges.

Note

If the memory object was created with the VK_MEMORY_PROPERTY_HOST_COHERENT_BIT set, vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges are unnecessary and may have a performance cost. However, availability and visibility operations still need to be managed on the device. See the description of host access types for more information.

Note

While memory objects imported from a handle type of VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT are inherently mapped to host address space, they are not considered to be host mapped device memory unless they are explicitly host mapped using vkMapMemory. That means flushing or invalidating host caches with respect to host accesses performed on such memory through the original host pointer specified at import time is the responsibility of the application and must be performed with appropriate synchronization primitives provided by the platform which are outside the scope of Vulkan. vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges, however, can still be used on such memory objects to synchronize host accesses performed through the host pointer of the host mapped device memory range returned by vkMapMemory.

To flush ranges of non-coherent memory from the host caches, call:

VkResult vkFlushMappedMemoryRanges(
    VkDevice                                    device,
    uint32_t                                    memoryRangeCount,
    const VkMappedMemoryRange*                  pMemoryRanges);

device is the logical device that owns the memory ranges.
memoryRangeCount is the length of the pMemoryRanges array.
pMemoryRanges is a pointer to an array of VkMappedMemoryRange structures describing the memory ranges to flush.

vkFlushMappedMemoryRanges guarantees that host writes to the memory ranges described by pMemoryRanges are made available to the host memory domain, such that they can be made available to the device memory domain via memory domain operations using the VK_ACCESS_HOST_WRITE_BIT access type.

Within each range described by pMemoryRanges, each set of nonCoherentAtomSize bytes in that range is flushed if any byte in that set has been written by the host since it was first host mapped, or the last time it was flushed. If pMemoryRanges includes sets of nonCoherentAtomSize bytes where no bytes have been written by the host, those bytes must not be flushed.

Unmapping non-coherent memory does not implicitly flush the host mapped memory, and host writes that have not been flushed may not ever be visible to the device. However, implementations must ensure that writes that have not been flushed do not become visible to any other memory.

Note

The above guarantee avoids a potential memory corruption in scenarios where host writes to a mapped memory object have not been flushed before the memory is unmapped (or freed), and the virtual address range is subsequently reused for a different mapping (or memory allocation).

Valid Usage (Implicit)

VUID-vkFlushMappedMemoryRanges-device-parameter
device must be a valid VkDevice handle
VUID-vkFlushMappedMemoryRanges-pMemoryRanges-parameter
pMemoryRanges must be a valid pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures
VUID-vkFlushMappedMemoryRanges-memoryRangeCount-arraylength
memoryRangeCount must be greater than 0

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

To invalidate ranges of non-coherent memory from the host caches, call:

VkResult vkInvalidateMappedMemoryRanges(
    VkDevice                                    device,
    uint32_t                                    memoryRangeCount,
    const VkMappedMemoryRange*                  pMemoryRanges);

device is the logical device that owns the memory ranges.
memoryRangeCount is the length of the pMemoryRanges array.
pMemoryRanges is a pointer to an array of VkMappedMemoryRange structures describing the memory ranges to invalidate.

vkInvalidateMappedMemoryRanges guarantees that device writes to the memory ranges described by pMemoryRanges, which have been made available to the host memory domain using the VK_ACCESS_HOST_WRITE_BIT and VK_ACCESS_HOST_READ_BIT access types, are made visible to the host. If a range of non-coherent memory is written by the host and then invalidated without first being flushed, its contents are undefined.

Within each range described by pMemoryRanges, each set of nonCoherentAtomSize bytes in that range is invalidated if any byte in that set has been written by the device since it was first host mapped, or the last time it was invalidated.

Note

Mapping non-coherent memory does not implicitly invalidate that memory.

Valid Usage (Implicit)

VUID-vkInvalidateMappedMemoryRanges-device-parameter
device must be a valid VkDevice handle
VUID-vkInvalidateMappedMemoryRanges-pMemoryRanges-parameter
pMemoryRanges must be a valid pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures
VUID-vkInvalidateMappedMemoryRanges-memoryRangeCount-arraylength
memoryRangeCount must be greater than 0

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkMappedMemoryRange structure is defined as:

typedef struct VkMappedMemoryRange {
    VkStructureType    sType;
    const void*        pNext;
    VkDeviceMemory     memory;
    VkDeviceSize       offset;
    VkDeviceSize       size;
} VkMappedMemoryRange;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
memory is the memory object to which this range belongs.
offset is the zero-based byte offset from the beginning of the memory object.
size is either the size of range, or VK_WHOLE_SIZE to affect the range from offset to the end of the current mapping of the allocation.

Valid Usage

VUID-VkMappedMemoryRange-memory-00684
memory must be currently host mapped
VUID-VkMappedMemoryRange-size-00685
If size is not equal to VK_WHOLE_SIZE, offset and size must specify a range contained within the currently mapped range of memory
VUID-VkMappedMemoryRange-size-00686
If size is equal to VK_WHOLE_SIZE, offset must be within the currently mapped range of memory
VUID-VkMappedMemoryRange-size-01389
If size is equal to VK_WHOLE_SIZE, the end of the current mapping of memory must be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize bytes from the beginning of the memory object.
VUID-VkMappedMemoryRange-offset-00687
offset must be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize
VUID-VkMappedMemoryRange-size-01390
If size is not equal to VK_WHOLE_SIZE, size must either be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize, or offset plus size must equal the size of memory.

Valid Usage (Implicit)

VUID-VkMappedMemoryRange-sType-sType
sType must be VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE
VUID-VkMappedMemoryRange-pNext-pNext
pNext must be NULL
VUID-VkMappedMemoryRange-memory-parameter
memory must be a valid VkDeviceMemory handle

To unmap a memory object once host access to it is no longer needed by the application, call:

void vkUnmapMemory(
    VkDevice                                    device,
    VkDeviceMemory                              memory);

device is the logical device that owns the memory.
memory is the memory object to be unmapped.

Valid Usage

VUID-vkUnmapMemory-memory-00689
memory must be currently host mapped

Valid Usage (Implicit)

VUID-vkUnmapMemory-device-parameter
device must be a valid VkDevice handle
VUID-vkUnmapMemory-memory-parameter
memory must be a valid VkDeviceMemory handle
VUID-vkUnmapMemory-memory-parent
memory must have been created, allocated, or retrieved from device

Host Synchronization

Host access to memory must be externally synchronized

10.2.2. Lazily Allocated Memory

If the memory object is allocated from a heap with the VK_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 VK_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.

To determine the amount of lazily-allocated memory that is currently committed for a memory object, call:

void vkGetDeviceMemoryCommitment(
    VkDevice                                    device,
    VkDeviceMemory                              memory,
    VkDeviceSize*                               pCommittedMemoryInBytes);

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

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.

Valid Usage

VUID-vkGetDeviceMemoryCommitment-memory-00690
memory must have been created with a memory type that reports VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT

Valid Usage (Implicit)

VUID-vkGetDeviceMemoryCommitment-device-parameter
device must be a valid VkDevice handle
VUID-vkGetDeviceMemoryCommitment-memory-parameter
memory must be a valid VkDeviceMemory handle
VUID-vkGetDeviceMemoryCommitment-pCommittedMemoryInBytes-parameter
pCommittedMemoryInBytes must be a valid pointer to a VkDeviceSize value
VUID-vkGetDeviceMemoryCommitment-memory-parent
memory must have been created, allocated, or retrieved from device

10.2.3. Protected Memory

Protected memory divides device memory into protected device memory and unprotected device memory.

Protected memory adds the following concepts:

Memory:
- Unprotected device memory, which can be visible to the device and can be visible to the host
- Protected device memory, which can be visible to the device but must not be visible to the host
Resources:
- Unprotected images and unprotected buffers, to which unprotected memory can be bound
- Protected images and protected buffers, to which protected memory can be bound
Command buffers:
- Unprotected command buffers, which can be submitted to a device queue to execute unprotected queue operations
- Protected command buffers, which can be submitted to a protected-capable device queue to execute protected queue operations
Device queues:
- Unprotected device queues, to which unprotected command buffers can be submitted
- Protected-capable device queues, to which unprotected command buffers or protected command buffers can be submitted
Queue submissions
- Unprotected queue submissions, through which unprotected command buffers can be submitted
- Protected queue submissions, through which protected command buffers can be submitted
Queue operations
- Unprotected queue operations
- Protected queue operations

Protected Memory Access Rules

If VkPhysicalDeviceProtectedMemoryProperties::protectedNoFault is VK_FALSE, applications must not perform any of the following operations:

Write to unprotected memory within protected queue operations.
Access protected memory within protected queue operations other than in framebuffer-space pipeline stages, the compute shader stage, or the transfer stage.
Perform a query within protected queue operations.
Execute an indirect command within protected queue operations.

If VkPhysicalDeviceProtectedMemoryProperties::protectedNoFault is VK_TRUE, these operations are valid, but reads will return undefined values, and writes will either be dropped or store undefined values.

Whether these operations are valid or not, or if any other invalid usage is performed, the implementation must guarantee that:

Protected device memory must never be visible to the host.
Values written to unprotected device memory must not be a function of values from protected memory.

10.2.4. External Memory Handle Types

Android Hardware Buffer

Android’s NDK defines AHardwareBuffer objects, which represent device memory that is shareable across processes and that can be accessed by a variety of media APIs and the hardware used to implement them. These Android hardware buffer objects may be imported into VkDeviceMemory objects for access via Vulkan, or exported from Vulkan.

To remove an unnecessary compile-time dependency, an incomplete type definition of AHardwareBuffer is provided in the Vulkan headers:

struct AHardwareBuffer;

The actual AHardwareBuffer type is defined in Android NDK headers.

Note

The NDK format, usage, and size/dimensions of an AHardwareBuffer object can be obtained with the AHardwareBuffer_describe function. While Android hardware buffers can be imported to or exported from Vulkan without using that function, valid usage and implementation behavior is defined in terms of the AHardwareBuffer_Desc properties it returns.

Android hardware buffer objects are reference-counted using Android NDK functions outside of the scope of this specification. A VkDeviceMemory imported from an Android hardware buffer or that can be exported to an Android hardware buffer must acquire a reference to its AHardwareBuffer object, and must release this reference when the device memory is freed. During the host execution of a Vulkan command that has an Android hardware buffer as a parameter (including indirect parameters via pNext chains), the application must not decrement the Android hardware buffer’s reference count to zero.

Android hardware buffers can be mapped and unmapped for CPU access using the NDK functions. These lock and unlock APIs are considered to acquire and release ownership of the Android hardware buffer, and applications must follow the rules described in External Resource Sharing to transfer ownership between the Vulkan instance and these native APIs.

Android hardware buffers can be shared with external APIs and Vulkan instances on the same device, and also with foreign devices. When transferring ownership of the Android hardware buffer, the external and foreign special queue families described in Queue Family Ownership Transfer are not identical. All APIs which produce or consume Android hardware buffers are considered to use foreign devices, except OpenGL ES contexts and Vulkan logical devices that have matching device and driver UUIDs. Implementations may treat a transfer to or from the foreign queue family as if it were a transfer to or from the external queue family when the Android hardware buffer’s usage only permits it to be used on the same physical device.

Android Hardware Buffer Optimal Usages

Vulkan buffer and image usage flags do not correspond exactly to Android hardware buffer usage flags. When allocating Android hardware buffers with non-Vulkan APIs, if any AHARDWAREBUFFER_USAGE_GPU_* usage bits are included, by default the allocator must allocate the memory in such a way that it supports Vulkan usages and creation flags in the usage equivalence table which do not have Android hardware buffer equivalents.

An VkAndroidHardwareBufferUsageANDROID structure can be included in the pNext chain of a VkImageFormatProperties2 instance passed to vkGetPhysicalDeviceImageFormatProperties2 to obtain optimal Android hardware buffer usage flags for specific Vulkan resource creation parameters. Some usage flags returned by these commands are required based on the input parameters, but additional vendor-specific usage flags (AHARDWAREBUFFER_USAGE_VENDOR_*) may also be returned. Any Android hardware buffer allocated with these vendor-specific usage flags and imported to Vulkan must only be bound to resources created with parameters that are a subset of the parameters used to obtain the Android hardware buffer usage, since the memory may have been allocated in a way incompatible with other parameters. If an Android hardware buffer is successfully allocated with additional non-vendor-specific usage flags in addition to the recommended usage, it must support being used in the same ways as an Android hardware buffer allocated with only the recommended usage, and also in ways indicated by the additional usage.

Android Hardware Buffer External Formats

Android hardware buffers may represent images using implementation-specific formats, layouts, color models, etc., which do not have Vulkan equivalents. Such external formats are commonly used by external image sources such as video decoders or cameras. Vulkan can import Android hardware buffers that have external formats, but since the image contents are in an undiscoverable and possibly proprietary representation, images with external formats must only be used as sampled images, must only be sampled with a sampler that has Y′C_BC_R conversion enabled, and must have optimal tiling.

Images that will be backed by an Android hardware buffer can use an external format by setting VkImageCreateInfo::format to VK_FORMAT_UNDEFINED and including a VkExternalFormatANDROID structure in the pNext chain. Images can be created with an external format even if the Android hardware buffer has a format which has an equivalent Vulkan format to enable consistent handling of images from sources that might use either category of format. However, all images created with an external format are subject to the valid usage requirements associated with external formats, even if the Android hardware buffer’s format has a Vulkan equivalent. The external format of an Android hardware buffer can be obtained by passing a VkAndroidHardwareBufferFormatPropertiesANDROID structure to vkGetAndroidHardwareBufferPropertiesANDROID.

Android Hardware Buffer Image Resources

Android hardware buffers have intrinsic width, height, format, and usage properties, so Vulkan images bound to memory imported from an Android hardware buffer must use dedicated allocations: VkMemoryDedicatedRequirements::requiresDedicatedAllocation must be VK_TRUE for images created with VkExternalMemoryImageCreateInfo::handleTypes that includes VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID. When creating an image that will be bound to an imported Android hardware buffer, the image creation parameters must be equivalent to the AHardwareBuffer properties as described by the valid usage of VkMemoryAllocateInfo. Similarly, device memory allocated for a dedicated image must not be exported to an Android hardware buffer until it has been bound to that image, and the implementation must return an Android hardware buffer with properties derived from the image:

The width and height members of AHardwareBuffer_Desc must be the same as the width and height members of VkImageCreateInfo::extent, respectively.
The layers member of AHardwareBuffer_Desc must be the same as the arrayLayers member of VkImageCreateInfo.
The format member of AHardwareBuffer_Desc must be equivalent to VkImageCreateInfo::format as defined by AHardwareBuffer Format Equivalence.
The usage member of AHardwareBuffer_Desc must include bits corresponding to bits included in VkImageCreateInfo::usage and VkImageCreateInfo::flags where such a correspondence exists according to AHardwareBuffer Usage Equivalence. It may also include additional usage bits, including vendor-specific usages. Presence of vendor usage bits may make the Android hardware buffer only usable in ways indicated by the image creation parameters, even when used outside Vulkan, in a similar way that allocating the Android hardware buffer with usage returned in VkAndroidHardwareBufferUsageANDROID does.

Implementations may support fewer combinations of image creation parameters for images with Android hardware buffer external handle type than for non-external images. Support for a given set of parameters can be determined by passing VkExternalImageFormatProperties to vkGetPhysicalDeviceImageFormatProperties2 with handleType set to VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID. Any Android hardware buffer successfully allocated outside Vulkan with usage that includes AHARDWAREBUFFER_USAGE_GPU_* must be supported when using equivalent Vulkan image parameters. If a given choice of image parameters are supported for import, they can also be used to create an image and memory that will be exported to an Android hardware buffer.

Table 13. AHardwareBuffer Format Equivalence
AHardwareBuffer Format	Vulkan Format
`AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM`	`VK_FORMAT_R8G8B8A8_UNORM`
`AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM` ¹	`VK_FORMAT_R8G8B8A8_UNORM`
`AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM`	`VK_FORMAT_R8G8B8_UNORM`
`AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM`	`VK_FORMAT_R5G6B5_UNORM_PACK16`
`AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT`	`VK_FORMAT_R16G16B16A16_SFLOAT`
`AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM`	`VK_FORMAT_A2B10G10R10_UNORM_PACK32`
`AHARDWAREBUFFER_FORMAT_D16_UNORM`	`VK_FORMAT_D16_UNORM`
`AHARDWAREBUFFER_FORMAT_D24_UNORM`	`VK_FORMAT_X8_D24_UNORM_PACK32`
`AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT`	`VK_FORMAT_D24_UNORM_S8_UINT`
`AHARDWAREBUFFER_FORMAT_D32_FLOAT`	`VK_FORMAT_D32_SFLOAT`
`AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT`	`VK_FORMAT_D32_SFLOAT_S8_UINT`
`AHARDWAREBUFFER_FORMAT_S8_UINT`	`VK_FORMAT_S8_UINT`

Table 14. AHardwareBuffer Usage Equivalence
AHardwareBuffer Usage	Vulkan Usage or Creation Flag
None	`VK_IMAGE_USAGE_TRANSFER_SRC_BIT`
None	`VK_IMAGE_USAGE_TRANSFER_DST_BIT`
`AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE`	`VK_IMAGE_USAGE_SAMPLED_BIT`
`AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE`	`VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT`
`AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT`	`VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT`
`AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP`	`VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT`
`AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE`	None ²
`AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT`	`VK_IMAGE_CREATE_PROTECTED_BIT`
None	`VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT`
None	`VK_IMAGE_CREATE_EXTENDED_USAGE_BIT`

1: Vulkan does not differentiate between AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM and AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM: they both behave as VK_FORMAT_R8G8B8A8_UNORM. After an external entity writes to a AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM Android hardware buffer, the values read by Vulkan from the X/A channel are undefined. To emulate the traditional behavior of the X channel during sampling or blending, applications should use VK_COMPONENT_SWIZZLE_ONE in image view component mappings and VK_BLEND_FACTOR_ONE in color blend factors. There is no way to avoid copying these undefined values when copying from such an image to another image or buffer.
2: The AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE flag does not correspond to a Vulkan image usage or creation flag. Instead, its presence indicates that the Android hardware buffer contains a complete mipmap chain, and its absence indicates that the Android hardware buffer contains only a single mip level.

Note

When using VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT with Android hardware buffer images, applications should use VkImageFormatListCreateInfo to inform the implementation which view formats will be used with the image. For some common sets of format, this allows some implementations to provide significantly better performance when accessing the image via Vulkan.

Android Hardware Buffer Buffer Resources

Android hardware buffers with a format of AHARDWAREBUFFER_FORMAT_BLOB and usage that includes AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER can be used as the backing store for VkBuffer objects. Such Android hardware buffers have a size in bytes specified by their width; height and layers are both 1.

Unlike images, buffer resources backed by Android hardware buffers do not require dedicated allocations.

Exported AHardwareBuffer objects that do not have dedicated images must have a format of AHARDWAREBUFFER_FORMAT_BLOB, usage must include AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER, width must equal the device memory allocation size, and height and layers must be 1.

10.2.5. Peer Memory Features

Peer memory is memory that is allocated for a given physical device and then bound to a resource and accessed by a different physical device, in a logical device that represents multiple physical devices. Some ways of reading and writing peer memory may not be supported by a device.

To determine how peer memory can be accessed, call:

void vkGetDeviceGroupPeerMemoryFeatures(
    VkDevice                                    device,
    uint32_t                                    heapIndex,
    uint32_t                                    localDeviceIndex,
    uint32_t                                    remoteDeviceIndex,
    VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);

or the equivalent command

void vkGetDeviceGroupPeerMemoryFeaturesKHR(
    VkDevice                                    device,
    uint32_t                                    heapIndex,
    uint32_t                                    localDeviceIndex,
    uint32_t                                    remoteDeviceIndex,
    VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);

device is the logical device that owns the memory.
heapIndex is the index of the memory heap from which the memory is allocated.
localDeviceIndex is the device index of the physical device that performs the memory access.
remoteDeviceIndex is the device index of the physical device that the memory is allocated for.
pPeerMemoryFeatures is a pointer to a VkPeerMemoryFeatureFlags bitmask indicating which types of memory accesses are supported for the combination of heap, local, and remote devices.

Valid Usage

VUID-vkGetDeviceGroupPeerMemoryFeatures-heapIndex-00691
heapIndex must be less than memoryHeapCount
VUID-vkGetDeviceGroupPeerMemoryFeatures-localDeviceIndex-00692
localDeviceIndex must be a valid device index
VUID-vkGetDeviceGroupPeerMemoryFeatures-remoteDeviceIndex-00693
remoteDeviceIndex must be a valid device index
VUID-vkGetDeviceGroupPeerMemoryFeatures-localDeviceIndex-00694
localDeviceIndex must not equal remoteDeviceIndex

Valid Usage (Implicit)

VUID-vkGetDeviceGroupPeerMemoryFeatures-device-parameter
device must be a valid VkDevice handle
VUID-vkGetDeviceGroupPeerMemoryFeatures-pPeerMemoryFeatures-parameter
pPeerMemoryFeatures must be a valid pointer to a VkPeerMemoryFeatureFlags value

Bits which may be set in the value returned for vkGetDeviceGroupPeerMemoryFeatures::pPeerMemoryFeatures, indicating the supported peer memory features, are:

typedef enum VkPeerMemoryFeatureFlagBits {
    VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001,
    VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002,
    VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004,
    VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008,
    VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
    VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,
    VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,
    VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT,
    VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkPeerMemoryFeatureFlagBits;

or the equivalent

typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR;

VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT specifies that the memory can be accessed as the source of a vkCmdCopyBuffer, vkCmdCopyImage, vkCmdCopyBufferToImage, or vkCmdCopyImageToBuffer command.
VK_PEER_MEMORY_FEATURE_COPY_DST_BIT specifies that the memory can be accessed as the destination of a vkCmdCopyBuffer, vkCmdCopyImage, vkCmdCopyBufferToImage, or vkCmdCopyImageToBuffer command.
VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT specifies that the memory can be read as any memory access type.
VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT specifies that the memory can be written as any memory access type. Shader atomics are considered to be writes.

Note

The peer memory features of a memory heap also apply to any accesses that may be performed during image layout transitions.

VK_PEER_MEMORY_FEATURE_COPY_DST_BIT must be supported for all host local heaps and for at least one device local heap.

If a device does not support a peer memory feature, it is still valid to use a resource that includes both local and peer memory bindings with the corresponding access type as long as only the local bindings are actually accessed. For example, an application doing split-frame rendering would use framebuffer attachments that include both local and peer memory bindings, but would scissor the rendering to only update local memory.

typedef VkFlags VkPeerMemoryFeatureFlags;

or the equivalent

typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR;

VkPeerMemoryFeatureFlags is a bitmask type for setting a mask of zero or more VkPeerMemoryFeatureFlagBits.

To query a 64-bit opaque capture address value from a memory object, call:

uint64_t vkGetDeviceMemoryOpaqueCaptureAddress(
    VkDevice                                    device,
    const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);

or the equivalent command

uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR(
    VkDevice                                    device,
    const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);

device is the logical device that the memory object was allocated on.
pInfo is a pointer to a VkDeviceMemoryOpaqueCaptureAddressInfo structure specifying the memory object to retrieve an address for.

The 64-bit return value is an opaque address representing the start of pInfo->memory.

If the memory object was allocated with a non-zero value of VkMemoryOpaqueCaptureAddressAllocateInfo::opaqueCaptureAddress, the return value must be the same address.

Note

The expected usage for these opaque addresses is only for trace capture/replay tools to store these addresses in a trace and subsequently specify them during replay.

Valid Usage

VUID-vkGetDeviceMemoryOpaqueCaptureAddress-None-03334
The bufferDeviceAddress feature must be enabled
VUID-vkGetDeviceMemoryOpaqueCaptureAddress-device-03335
If device was created with multiple physical devices, then the bufferDeviceAddressMultiDevice feature must be enabled

Valid Usage (Implicit)

VUID-vkGetDeviceMemoryOpaqueCaptureAddress-device-parameter
device must be a valid VkDevice handle
VUID-vkGetDeviceMemoryOpaqueCaptureAddress-pInfo-parameter
pInfo must be a valid pointer to a valid VkDeviceMemoryOpaqueCaptureAddressInfo structure

The VkDeviceMemoryOpaqueCaptureAddressInfo structure is defined as:

typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo {
    VkStructureType    sType;
    const void*        pNext;
    VkDeviceMemory     memory;
} VkDeviceMemoryOpaqueCaptureAddressInfo;

or the equivalent

typedef VkDeviceMemoryOpaqueCaptureAddressInfo VkDeviceMemoryOpaqueCaptureAddressInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
memory specifies the memory whose address is being queried.

Valid Usage

VUID-VkDeviceMemoryOpaqueCaptureAddressInfo-memory-03336
memory must have been allocated with VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT

Valid Usage (Implicit)

VUID-VkDeviceMemoryOpaqueCaptureAddressInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO
VUID-VkDeviceMemoryOpaqueCaptureAddressInfo-pNext-pNext
pNext must be NULL
VUID-VkDeviceMemoryOpaqueCaptureAddressInfo-memory-parameter
memory must be a valid VkDeviceMemory handle

11. Resource Creation

Vulkan supports two primary resource types: buffers and images. Resources are views of memory with associated formatting and dimensionality. Buffers are essentially unformatted arrays of bytes whereas images contain format information, can be multidimensional and may have associated metadata.

11.1. Buffers

Buffers represent linear arrays of data which are used for various purposes by binding them to a graphics or compute pipeline via descriptor sets or via certain commands, or by directly specifying them as parameters to certain commands.

Buffers are represented by VkBuffer handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)

To create buffers, call:

VkResult vkCreateBuffer(
    VkDevice                                    device,
    const VkBufferCreateInfo*                   pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkBuffer*                                   pBuffer);

device is the logical device that creates the buffer object.
pCreateInfo is a pointer to a VkBufferCreateInfo structure containing parameters affecting creation of the buffer.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pBuffer is a pointer to a VkBuffer handle in which the resulting buffer object is returned.

Valid Usage

VUID-vkCreateBuffer-flags-00911
If the flags member of pCreateInfo includes VK_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

Valid Usage (Implicit)

VUID-vkCreateBuffer-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateBuffer-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkBufferCreateInfo structure
VUID-vkCreateBuffer-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateBuffer-pBuffer-parameter
pBuffer must be a valid pointer to a VkBuffer handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR

The VkBufferCreateInfo structure is defined as:

typedef struct VkBufferCreateInfo {
    VkStructureType        sType;
    const void*            pNext;
    VkBufferCreateFlags    flags;
    VkDeviceSize           size;
    VkBufferUsageFlags     usage;
    VkSharingMode          sharingMode;
    uint32_t               queueFamilyIndexCount;
    const uint32_t*        pQueueFamilyIndices;
} VkBufferCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkBufferCreateFlagBits specifying additional parameters of the buffer.
size is the size in bytes of the buffer to be created.
usage is a bitmask of VkBufferUsageFlagBits specifying allowed usages of the buffer.
sharingMode is a VkSharingMode value specifying the sharing mode of the buffer when it will be accessed by multiple queue families.
queueFamilyIndexCount is the number of entries in the pQueueFamilyIndices array.
pQueueFamilyIndices is a list of queue families that will access this buffer (ignored if sharingMode is not VK_SHARING_MODE_CONCURRENT).

Valid Usage

VUID-VkBufferCreateInfo-size-00912
size must be greater than 0
VUID-VkBufferCreateInfo-sharingMode-00913
If sharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values
VUID-VkBufferCreateInfo-sharingMode-00914
If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1
VUID-VkBufferCreateInfo-sharingMode-01419
If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device
VUID-VkBufferCreateInfo-flags-00915
If the sparse bindings feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT
VUID-VkBufferCreateInfo-flags-00916
If the sparse buffer residency feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT
VUID-VkBufferCreateInfo-flags-00917
If the sparse aliased residency feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_ALIASED_BIT
VUID-VkBufferCreateInfo-flags-00918
If flags contains VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT
VUID-VkBufferCreateInfo-pNext-00920
If the pNext chain includes a VkExternalMemoryBufferCreateInfo structure, its handleTypes member must only contain bits that are also in VkExternalBufferProperties::externalMemoryProperties.compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalBufferProperties with pExternalBufferInfo->handleType equal to any one of the handle types specified in VkExternalMemoryBufferCreateInfo::handleTypes
VUID-VkBufferCreateInfo-flags-01887
If the protected memory feature is not enabled, flags must not contain VK_BUFFER_CREATE_PROTECTED_BIT
VUID-VkBufferCreateInfo-None-01888
If any of the bits VK_BUFFER_CREATE_SPARSE_BINDING_BIT, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT are set, VK_BUFFER_CREATE_PROTECTED_BIT must not also be set
VUID-VkBufferCreateInfo-pNext-01571
If the pNext chain includes a VkDedicatedAllocationBufferCreateInfoNV structure, and the dedicatedAllocation member of the chained structure is VK_TRUE, then flags must not include VK_BUFFER_CREATE_SPARSE_BINDING_BIT, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT
VUID-VkBufferCreateInfo-deviceAddress-02604
If VkBufferDeviceAddressCreateInfoEXT::deviceAddress is not zero, flags must include VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT
VUID-VkBufferCreateInfo-opaqueCaptureAddress-03337
If VkBufferOpaqueCaptureAddressCreateInfo::opaqueCaptureAddress is not zero, flags must include VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT
VUID-VkBufferCreateInfo-flags-03338
If flags includes VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, the bufferDeviceAddressCaptureReplay or VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::bufferDeviceAddressCaptureReplay feature must be enabled

Valid Usage (Implicit)

VUID-VkBufferCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
VUID-VkBufferCreateInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkBufferDeviceAddressCreateInfoEXT, VkBufferOpaqueCaptureAddressCreateInfo, VkDedicatedAllocationBufferCreateInfoNV, or VkExternalMemoryBufferCreateInfo
VUID-VkBufferCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkBufferCreateInfo-flags-parameter
flags must be a valid combination of VkBufferCreateFlagBits values
VUID-VkBufferCreateInfo-usage-parameter
usage must be a valid combination of VkBufferUsageFlagBits values
VUID-VkBufferCreateInfo-usage-requiredbitmask
usage must not be 0
VUID-VkBufferCreateInfo-sharingMode-parameter
sharingMode must be a valid VkSharingMode value

Bits which can be set in VkBufferCreateInfo::usage, specifying usage behavior of a buffer, are:

typedef enum VkBufferUsageFlagBits {
    VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
    VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
    VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
    VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
    VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
    VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
    VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
    VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
    VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
    VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0x00020000,
    VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800,
    VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000,
    VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200,
    VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = 0x00000400,
    VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
    VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
    VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkBufferUsageFlagBits;

VK_BUFFER_USAGE_TRANSFER_SRC_BIT specifies that the buffer can be used as the source of a transfer command (see the definition of VK_PIPELINE_STAGE_TRANSFER_BIT).
VK_BUFFER_USAGE_TRANSFER_DST_BIT specifies that the buffer can be used as the destination of a transfer command.
VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT specifies that the buffer can be used to create a VkBufferView suitable for occupying a VkDescriptorSet slot of type VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER.
VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT specifies that the buffer can be used to create a VkBufferView suitable for occupying a VkDescriptorSet slot of type VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER.
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT specifies that the buffer can be used in a VkDescriptorBufferInfo suitable for occupying a VkDescriptorSet slot either of type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC.
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT specifies that the buffer can be used in a VkDescriptorBufferInfo suitable for occupying a VkDescriptorSet slot either of type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC.
VK_BUFFER_USAGE_INDEX_BUFFER_BIT specifies that the buffer is suitable for passing as the buffer parameter to vkCmdBindIndexBuffer.
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT specifies that the buffer is suitable for passing as an element of the pBuffers array to vkCmdBindVertexBuffers.
VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT specifies that the buffer is suitable for passing as the buffer parameter to vkCmdDrawIndirect, vkCmdDrawIndexedIndirect, vkCmdDrawMeshTasksIndirectNV, vkCmdDrawMeshTasksIndirectCountNV, or vkCmdDispatchIndirect. It is also suitable for passing as the buffer member of VkIndirectCommandsTokenNVX, or sequencesCountBuffer or sequencesIndexBuffer member of VkCmdProcessCommandsInfoNVX
VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT specifies that the buffer is suitable for passing as the buffer parameter to vkCmdBeginConditionalRenderingEXT.
VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT specifies that the buffer is suitable for using for binding as a transform feedback buffer with vkCmdBindTransformFeedbackBuffersEXT.
VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT specifies that the buffer is suitable for using as a counter buffer with vkCmdBeginTransformFeedbackEXT and vkCmdEndTransformFeedbackEXT.
VK_BUFFER_USAGE_RAY_TRACING_BIT_NV specifies that the buffer is suitable for use in vkCmdTraceRaysNV and vkCmdBuildAccelerationStructureNV.
VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT specifies that the buffer can be used to retrieve a buffer device address via vkGetBufferDeviceAddress and use that address to access the buffer’s memory from a shader.

typedef VkFlags VkBufferUsageFlags;

VkBufferUsageFlags is a bitmask type for setting a mask of zero or more VkBufferUsageFlagBits.

Bits which can be set in VkBufferCreateInfo::flags, specifying additional parameters of a buffer, are:

typedef enum VkBufferCreateFlagBits {
    VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
    VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
    VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
    VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008,
    VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000010,
    VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
    VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
    VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkBufferCreateFlagBits;

VK_BUFFER_CREATE_SPARSE_BINDING_BIT specifies that the buffer will be backed using sparse memory binding.
VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT specifies that the buffer can be partially backed using sparse memory binding. Buffers created with this flag must also be created with the VK_BUFFER_CREATE_SPARSE_BINDING_BIT flag.
VK_BUFFER_CREATE_SPARSE_ALIASED_BIT specifies 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 VK_BUFFER_CREATE_SPARSE_BINDING_BIT flag.
VK_BUFFER_CREATE_PROTECTED_BIT specifies that the buffer is a protected buffer.
VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT specifies that the buffer’s address can be saved and reused on a subsequent run (e.g. for trace capture and replay), see VkBufferOpaqueCaptureAddressCreateInfo for more detail.

See Sparse Resource Features and Physical Device Features for details of the sparse memory features supported on a device.

typedef VkFlags VkBufferCreateFlags;

VkBufferCreateFlags is a bitmask type for setting a mask of zero or more VkBufferCreateFlagBits.

If the pNext chain includes a VkDedicatedAllocationBufferCreateInfoNV structure, then that structure includes an enable controlling whether the buffer will have a dedicated memory allocation bound to it.

The VkDedicatedAllocationBufferCreateInfoNV structure is defined as:

typedef struct VkDedicatedAllocationBufferCreateInfoNV {
    VkStructureType    sType;
    const void*        pNext;
    VkBool32           dedicatedAllocation;
} VkDedicatedAllocationBufferCreateInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
dedicatedAllocation specifies whether the buffer will have a dedicated allocation bound to it.

Valid Usage (Implicit)

VUID-VkDedicatedAllocationBufferCreateInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV

To define a set of external memory handle types that may be used as backing store for a buffer, add a VkExternalMemoryBufferCreateInfo structure to the pNext chain of the VkBufferCreateInfo structure. The VkExternalMemoryBufferCreateInfo structure is defined as:

typedef struct VkExternalMemoryBufferCreateInfo {
    VkStructureType                    sType;
    const void*                        pNext;
    VkExternalMemoryHandleTypeFlags    handleTypes;
} VkExternalMemoryBufferCreateInfo;

or the equivalent

typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR;

Note

A VkExternalMemoryBufferCreateInfo structure must be included in the creation parameters for a buffer that will be bound to memory that is either exported or imported.

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
handleTypes is a bitmask of VkExternalMemoryHandleTypeFlagBits specifying one or more external memory handle types.

Valid Usage (Implicit)

VUID-VkExternalMemoryBufferCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO
VUID-VkExternalMemoryBufferCreateInfo-handleTypes-parameter
handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values

To request a specific device address for a buffer, add a VkBufferOpaqueCaptureAddressCreateInfo structure to the pNext chain of the VkBufferCreateInfo structure. The VkBufferOpaqueCaptureAddressCreateInfo structure is defined as:

typedef struct VkBufferOpaqueCaptureAddressCreateInfo {
    VkStructureType    sType;
    const void*        pNext;
    uint64_t           opaqueCaptureAddress;
} VkBufferOpaqueCaptureAddressCreateInfo;

or the equivalent

typedef VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
opaqueCaptureAddress is the opaque capture address requested for the buffer.

If opaqueCaptureAddress is zero, no specific address is requested.

If opaqueCaptureAddress is not zero, then it should be an address retrieved from vkGetBufferOpaqueCaptureAddress for an identically created buffer on the same implementation.

If this structure is not present, it is as if opaqueCaptureAddress is zero.

Apps should avoid creating buffers with app-provided addresses and implementation-provided addresses in the same process, to reduce the likelihood of VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS errors.

Note

The expected usage for this is that a trace capture/replay tool will add the VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT flag to all buffers that use VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, and during capture will save the queried opaque device addresses in the trace. During replay, the buffers will be created specifying the original address so any address values stored in the trace data will remain valid.

Implementations are expected to separate such buffers in the GPU address space so normal allocations will avoid using these addresses. Apps/tools should avoid mixing app-provided and implementation-provided addresses for buffers created with VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, to avoid address space allocation conflicts.

Valid Usage (Implicit)

VUID-VkBufferOpaqueCaptureAddressCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO

Alternatively, to request a specific device address for a buffer, add a VkBufferDeviceAddressCreateInfoEXT structure to the pNext chain of the VkBufferCreateInfo structure. The VkBufferDeviceAddressCreateInfoEXT structure is defined as:

typedef struct VkBufferDeviceAddressCreateInfoEXT {
    VkStructureType    sType;
    const void*        pNext;
    VkDeviceAddress    deviceAddress;
} VkBufferDeviceAddressCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
deviceAddress is the device address requested for the buffer.

If deviceAddress is zero, no specific address is requested.

If deviceAddress is not zero, then it must be an address retrieved from an identically created buffer on the same implementation. The buffer must also be bound to an identically created VkDeviceMemory object.

If this structure is not present, it is as if deviceAddress is zero.

Apps should avoid creating buffers with app-provided addresses and implementation-provided addresses in the same process, to reduce the likelihood of VK_ERROR_INVALID_DEVICE_ADDRESS_EXT errors.

Valid Usage (Implicit)

VUID-VkBufferDeviceAddressCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT

To destroy a buffer, call:

void vkDestroyBuffer(
    VkDevice                                    device,
    VkBuffer                                    buffer,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the buffer.
buffer is the buffer to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyBuffer-buffer-00922
All submitted commands that refer to buffer, either directly or via a VkBufferView, must have completed execution
VUID-vkDestroyBuffer-buffer-00923
If VkAllocationCallbacks were provided when buffer was created, a compatible set of callbacks must be provided here
VUID-vkDestroyBuffer-buffer-00924
If no VkAllocationCallbacks were provided when buffer was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyBuffer-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyBuffer-buffer-parameter
If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle
VUID-vkDestroyBuffer-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyBuffer-buffer-parent
If buffer is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to buffer must be externally synchronized

11.2. Buffer Views

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:

VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT
VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT

Buffer views are represented by VkBufferView handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)

To create a buffer view, call:

VkResult vkCreateBufferView(
    VkDevice                                    device,
    const VkBufferViewCreateInfo*               pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkBufferView*                               pView);

device is the logical device that creates the buffer view.
pCreateInfo is a pointer to a VkBufferViewCreateInfo structure containing parameters to be used to create the buffer.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pView is a pointer to a VkBufferView handle in which the resulting buffer view object is returned.

Valid Usage (Implicit)

VUID-vkCreateBufferView-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateBufferView-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkBufferViewCreateInfo structure
VUID-vkCreateBufferView-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateBufferView-pView-parameter
pView must be a valid pointer to a VkBufferView handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkBufferViewCreateInfo structure is defined as:

typedef struct VkBufferViewCreateInfo {
    VkStructureType            sType;
    const void*                pNext;
    VkBufferViewCreateFlags    flags;
    VkBuffer                   buffer;
    VkFormat                   format;
    VkDeviceSize               offset;
    VkDeviceSize               range;
} VkBufferViewCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
buffer is a VkBuffer on which the view will be created.
format is a VkFormat describing the format of the data elements in the buffer.
offset is an offset in bytes from the base address of the buffer. Accesses to the buffer view from shaders use addressing that is relative to this starting offset.
range is a size in bytes of the buffer view. If range is equal to VK_WHOLE_SIZE, the range from offset to the end of the buffer is used. If VK_WHOLE_SIZE is used and the remaining size of the buffer is not a multiple of the texel block size of format, the nearest smaller multiple is used.

Valid Usage

VUID-VkBufferViewCreateInfo-offset-00925
offset must be less than the size of buffer
VUID-VkBufferViewCreateInfo-range-00928
If range is not equal to VK_WHOLE_SIZE, range must be greater than 0
VUID-VkBufferViewCreateInfo-range-00929
If range is not equal to VK_WHOLE_SIZE, range must be an integer multiple of the texel block size of format
VUID-VkBufferViewCreateInfo-range-00930
If range is not equal to VK_WHOLE_SIZE, range divided by the texel block size of format, multiplied by the number of texels per texel block for that format (as defined in the Compatible Formats table), must be less than or equal to VkPhysicalDeviceLimits::maxTexelBufferElements
VUID-VkBufferViewCreateInfo-offset-00931
If range is not equal to VK_WHOLE_SIZE, the sum of offset and range must be less than or equal to the size of buffer
VUID-VkBufferViewCreateInfo-buffer-00932
buffer must have been created with a usage value containing at least one of VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT
VUID-VkBufferViewCreateInfo-buffer-00933
If buffer was created with usage containing VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, format must be supported for uniform texel buffers, as specified by the VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties
VUID-VkBufferViewCreateInfo-buffer-00934
If buffer was created with usage containing VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, format must be supported for storage texel buffers, as specified by the VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties
VUID-VkBufferViewCreateInfo-buffer-00935
If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-VkBufferViewCreateInfo-offset-02749
If the texelBufferAlignment feature is not enabled, offset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment
VUID-VkBufferViewCreateInfo-buffer-02750
If the texelBufferAlignment feature is enabled and if buffer was created with usage containing VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, offset must be a multiple of the lesser of VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::storageTexelBufferOffsetAlignmentBytes or, if VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::storageTexelBufferOffsetSingleTexelAlignment is VK_TRUE, the size of a texel of the requested format. If the size of a texel is a multiple of three bytes, then the size of a single component of format is used instead
VUID-VkBufferViewCreateInfo-buffer-02751
If the texelBufferAlignment feature is enabled and if buffer was created with usage containing VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, offset must be a multiple of the lesser of VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::uniformTexelBufferOffsetAlignmentBytes or, if VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::uniformTexelBufferOffsetSingleTexelAlignment is VK_TRUE, the size of a texel of the requested format. If the size of a texel is a multiple of three bytes, then the size of a single component of format is used instead

Valid Usage (Implicit)

VUID-VkBufferViewCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
VUID-VkBufferViewCreateInfo-pNext-pNext
pNext must be NULL
VUID-VkBufferViewCreateInfo-flags-zerobitmask
flags must be 0
VUID-VkBufferViewCreateInfo-buffer-parameter
buffer must be a valid VkBuffer handle
VUID-VkBufferViewCreateInfo-format-parameter
format must be a valid VkFormat value

typedef VkFlags VkBufferViewCreateFlags;

VkBufferViewCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

To destroy a buffer view, call:

void vkDestroyBufferView(
    VkDevice                                    device,
    VkBufferView                                bufferView,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the buffer view.
bufferView is the buffer view to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyBufferView-bufferView-00936
All submitted commands that refer to bufferView must have completed execution
VUID-vkDestroyBufferView-bufferView-00937
If VkAllocationCallbacks were provided when bufferView was created, a compatible set of callbacks must be provided here
VUID-vkDestroyBufferView-bufferView-00938
If no VkAllocationCallbacks were provided when bufferView was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyBufferView-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyBufferView-bufferView-parameter
If bufferView is not VK_NULL_HANDLE, bufferView must be a valid VkBufferView handle
VUID-vkDestroyBufferView-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyBufferView-bufferView-parent
If bufferView is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to bufferView must be externally synchronized

11.3. Images

Images represent multidimensional - up to 3 - arrays of data which can be used for various purposes (e.g. attachments, textures), by binding them to a graphics or compute pipeline via descriptor sets, or by directly specifying them as parameters to certain commands.

Images are represented by VkImage handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)

To create images, call:

VkResult vkCreateImage(
    VkDevice                                    device,
    const VkImageCreateInfo*                    pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkImage*                                    pImage);

device is the logical device that creates the image.
pCreateInfo is a pointer to a VkImageCreateInfo structure containing parameters to be used to create the image.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pImage is a pointer to a VkImage handle in which the resulting image object is returned.

Valid Usage

VUID-vkCreateImage-flags-00939
If the flags member of pCreateInfo includes VK_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

Valid Usage (Implicit)

VUID-vkCreateImage-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateImage-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkImageCreateInfo structure
VUID-vkCreateImage-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateImage-pImage-parameter
pImage must be a valid pointer to a VkImage handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkImageCreateInfo structure is defined as:

typedef struct VkImageCreateInfo {
    VkStructureType          sType;
    const void*              pNext;
    VkImageCreateFlags       flags;
    VkImageType              imageType;
    VkFormat                 format;
    VkExtent3D               extent;
    uint32_t                 mipLevels;
    uint32_t                 arrayLayers;
    VkSampleCountFlagBits    samples;
    VkImageTiling            tiling;
    VkImageUsageFlags        usage;
    VkSharingMode            sharingMode;
    uint32_t                 queueFamilyIndexCount;
    const uint32_t*          pQueueFamilyIndices;
    VkImageLayout            initialLayout;
} VkImageCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkImageCreateFlagBits describing additional parameters of the image.
imageType is a VkImageType value specifying the basic dimensionality of the image. Layers in array textures do not count as a dimension for the purposes of the image type.
format is a VkFormat describing the format and type of the texel blocks that will be contained in the image.
extent is a VkExtent3D describing the number of data elements in each dimension of the base level.
mipLevels describes the number of levels of detail available for minified sampling of the image.
arrayLayers is the number of layers in the image.
samples is a VkSampleCountFlagBits specifying the number of samples per texel.
tiling is a VkImageTiling value specifying the tiling arrangement of the texel blocks in memory.
usage is a bitmask of VkImageUsageFlagBits describing the intended usage of the image.
sharingMode is a VkSharingMode value specifying the sharing mode of the image when it will be accessed by multiple queue families.
queueFamilyIndexCount is the number of entries in the pQueueFamilyIndices array.
pQueueFamilyIndices is a list of queue families that will access this image (ignored if sharingMode is not VK_SHARING_MODE_CONCURRENT).
initialLayout is a VkImageLayout value specifying the initial VkImageLayout of all image subresources of the image. See Image Layouts.

Images created with tiling equal to VK_IMAGE_TILING_LINEAR have further restrictions on their limits and capabilities compared to images created with tiling equal to VK_IMAGE_TILING_OPTIMAL. Creation of images with tiling VK_IMAGE_TILING_LINEAR may not be supported unless other parameters meet all of the constraints:

imageType is VK_IMAGE_TYPE_2D
format is not a depth/stencil format
mipLevels is 1
arrayLayers is 1
samples is VK_SAMPLE_COUNT_1_BIT
usage only includes VK_IMAGE_USAGE_TRANSFER_SRC_BIT and/or VK_IMAGE_USAGE_TRANSFER_DST_BIT

Images created with a format from one of those listed in Formats requiring sampler Y′C_BC_R conversion for VK_IMAGE_ASPECT_COLOR_BIT image views have further restrictions on their limits and capabilities compared to images created with other formats. Creation of images with a format requiring Y′C_BC_R conversion may not be supported unless other parameters meet all of the constraints:

imageType is VK_IMAGE_TYPE_2D
mipLevels is 1
arrayLayers is 1
samples is VK_SAMPLE_COUNT_1_BIT

Implementations may support additional limits and capabilities beyond those listed above.

To determine the set of valid usage bits for a given format, call vkGetPhysicalDeviceFormatProperties.

If the size of the resultant image would exceed maxResourceSize, then vkCreateImage must fail and return VK_ERROR_OUT_OF_DEVICE_MEMORY. This failure may occur even when all image creation parameters satisfy their valid usage requirements.

Note

For images created without VK_IMAGE_CREATE_EXTENDED_USAGE_BIT a usage bit is valid if it is supported for the format the image is created with.

For images created with VK_IMAGE_CREATE_EXTENDED_USAGE_BIT a usage bit is valid if it is supported for at least one of the formats a VkImageView created from the image can have (see Image Views for more detail).

Image Creation Limits

Valid values for some image creation parameters are limited by a numerical upper bound or by inclusion in a bitset. For example, VkImageCreateInfo::arrayLayers is limited by imageCreateMaxArrayLayers, defined below; and VkImageCreateInfo::samples is limited by imageCreateSampleCounts, also defined below.

Several limiting values are defined below, as well as assisting values from which the limiting values are derived. The limiting values are referenced by the relevant valid usage statements of VkImageCreateInfo.

Let uint64_t imageCreateDrmFormatModifiers[] be the set of Linux DRM format modifiers that the resultant image may have.
- If tiling is not VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then imageCreateDrmFormatModifiers is empty.
- If VkImageCreateInfo::pNext contains VkImageDrmFormatModifierExplicitCreateInfoEXT, then imageCreateDrmFormatModifiers contains exactly one modifier, VkImageDrmFormatModifierExplicitCreateInfoEXT::drmFormatModifier.
- If VkImageCreateInfo::pNext contains VkImageDrmFormatModifierListCreateInfoEXT, then imageCreateDrmFormatModifiers contains the exactly the modifiers in VkImageDrmFormatModifierListCreateInfoEXT::pDrmFormatModifiers.
Let VkBool32 imageCreateMaybeLinear indicate if the resultant image may be linear.
- If tiling is VK_IMAGE_TILING_LINEAR, then imageCreateMaybeLinear is true.
- If tiling is VK_IMAGE_TILING_OPTIMAL, then imageCreateMaybeLinear is false.
- If tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then imageCreateMaybeLinear_ is true if and only if imageCreateDrmFormatModifiers contains DRM_FORMAT_MOD_LINEAR.
Let VkFormatFeatureFlags imageCreateFormatFeatures be the set of format features available during image creation.
- If tiling is VK_IMAGE_TILING_LINEAR, then imageCreateFormatFeatures is the value of VkImageFormatProperties::linearTilingFeatures found by calling vkGetPhysicalDeviceFormatProperties with parameter format equal to VkImageCreateInfo::format.
- If tiling is VK_IMAGE_TILING_OPTIMAL, and if the pNext chain includes no VkExternalFormatANDROID structure with non-zero externalFormat, then imageCreateFormatFeatures is value of VkImageFormatProperties::optimalTilingFeatures found by calling vkGetPhysicalDeviceFormatProperties with parameter format equal to VkImageCreateInfo::format.
- If tiling is VK_IMAGE_TILING_OPTIMAL, and if the pNext chain includes a VkExternalFormatANDROID structure with non-zero externalFormat, then imageCreateFormatFeatures is the value of VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures obtained by vkGetAndroidHardwareBufferPropertiesANDROID with a matching externalFormat value.
- If tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then the value of imageCreateFormatFeatures is found by calling vkGetPhysicalDeviceFormatProperties2 with VkImageFormatProperties::format equal to VkImageCreateInfo::format and with VkDrmFormatModifierPropertiesListEXT chained into VkImageFormatProperties2; by collecting all members of the returned array VkDrmFormatModifierPropertiesListEXT::pDrmFormatModifierProperties whose drmFormatModifier belongs to imageCreateDrmFormatModifiers; and by taking the bitwise intersection, over the collected array members, of drmFormatModifierTilingFeatures. (The resultant imageCreateFormatFeatures may be empty).
Let VkImageFormatProperties2 imageCreateImageFormatPropertiesList[] be defined as follows.
- If VkImageCreateInfo::pNext contains no VkExternalFormatANDROID structure with non-zero externalFormat, then imageCreateImageFormatPropertiesList is the list of structures obtained by calling vkGetPhysicalDeviceImageFormatProperties2, possibly multiple times, as follows:
  - The parameters VkPhysicalDeviceImageFormatInfo2::format, imageType, tiling, usage, and flags must be equal to those in VkImageCreateInfo.
  - If VkImageCreateInfo::pNext contains a VkExternalMemoryImageCreateInfo structure whose handleTypes is not 0, then VkPhysicalDeviceImageFormatInfo2::pNext must contain a VkPhysicalDeviceExternalImageFormatInfo structure whose handleType is not 0; and vkGetPhysicalDeviceImageFormatProperties2 must be called for each handle type in VkExternalMemoryImageCreateInfo::handleTypes, successively setting VkPhysicalDeviceExternalImageFormatInfo::handleType on each call.
  - If VkImageCreateInfo::pNext contains no VkExternalMemoryImageCreateInfo structure, or contains a structure whose handleTypes is 0, then VkPhysicalDeviceImageFormatInfo2::pNext must either contain no VkPhysicalDeviceExternalImageFormatInfo structure, or contain a structure whose handleType is 0.
  - If tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then VkPhysicalDeviceImageFormatInfo2::pNext must contain a VkPhysicalDeviceImageDrmFormatModifierInfoEXT structure where sharingMode is equal to VkImageCreateInfo::sharingMode; and, if sharingMode is VK_SHARING_MODE_CONCURRENT, then queueFamilyIndexCount and pQueueFamilyIndices must be equal to those in VkImageCreateInfo; and, if flags contains VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, then the VkImageFormatListCreateInfo structure included in the pNext chain of VkPhysicalDeviceImageFormatInfo2 must be equivalent to the one included in the pNext chain of VkImageCreateInfo; and vkGetPhysicalDeviceImageFormatProperties2 must be called for each modifier in imageCreateDrmFormatModifiers, successively setting VkPhysicalDeviceImageDrmFormatModifierInfoEXT::drmFormatModifier on each call.
  - If tiling is not VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then VkPhysicalDeviceImageFormatInfo2::pNext must contain no VkPhysicalDeviceImageDrmFormatModifierInfoEXT structure.
  - If any call to vkGetPhysicalDeviceImageFormatProperties2 returns an error, then imageCreateImageFormatPropertiesList is defined to be the empty list.
- If VkImageCreateInfo::pNext contains a VkExternalFormatANDROID structure with non-zero externalFormat, then imageCreateImageFormatPropertiesList contains a single element where:
  - VkImageFormatProperties::maxMipLevels is ⌊log₂(max(extent.width, extent.height, extent.depth))⌋ + 1.
  - VkImageFormatProperties::maxArrayLayers is VkPhysicalDeviceLimits::maxImageArrayLayers.
  - Each component of VkImageFormatProperties::maxExtent is VkPhysicalDeviceLimits::maxImageDimension2D.
  - VkImageFormatProperties::sampleCounts contains exactly VK_SAMPLE_COUNT_1_BIT.
Let uint32_t imageCreateMaxMipLevels be the minimum value of VkImageFormatProperties::maxMipLevels in imageCreateImageFormatPropertiesList. The value is undefined if imageCreateImageFormatPropertiesList is empty.
Let uint32_t imageCreateMaxArrayLayers be the minimum value of VkImageFormatProperties::maxArrayLayers in imageCreateImageFormatPropertiesList. The value is undefined if imageCreateImageFormatPropertiesList is empty.
Let VkExtent3D imageCreateMaxExtent be the component-wise minimum over all VkImageFormatProperties::maxExtent values in imageCreateImageFormatPropertiesList. The value is undefined if imageCreateImageFormatPropertiesList is empty.
Let VkSampleCountFlags imageCreateSampleCounts be the intersection of each VkImageFormatProperties::sampleCounts in imageCreateImageFormatPropertiesList. The value is undefined if imageCreateImageFormatPropertiesList is empty.

Valid Usage

VUID-VkImageCreateInfo-imageCreateMaxMipLevels-02251
Each of the following values (as described in Image Creation Limits) must not be undefined imageCreateMaxMipLevels, imageCreateMaxArrayLayers, imageCreateMaxExtent, and imageCreateSampleCounts.
VUID-VkImageCreateInfo-sharingMode-00941
If sharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values
VUID-VkImageCreateInfo-sharingMode-00942
If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1
VUID-VkImageCreateInfo-sharingMode-01420
If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device
VUID-VkImageCreateInfo-pNext-01974
If the pNext chain includes a VkExternalFormatANDROID structure, and its externalFormat member is non-zero the format must be VK_FORMAT_UNDEFINED.
VUID-VkImageCreateInfo-pNext-01975
If the pNext chain does not include a VkExternalFormatANDROID structure, or does and its externalFormat member is 0, the format must not be VK_FORMAT_UNDEFINED.
VUID-VkImageCreateInfo-extent-00944
extent.width must be greater than 0.
VUID-VkImageCreateInfo-extent-00945
extent.height must be greater than 0.
VUID-VkImageCreateInfo-extent-00946
extent.depth must be greater than 0.
VUID-VkImageCreateInfo-mipLevels-00947
mipLevels must be greater than 0
VUID-VkImageCreateInfo-arrayLayers-00948
arrayLayers must be greater than 0
VUID-VkImageCreateInfo-flags-00949
If flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, imageType must be VK_IMAGE_TYPE_2D
VUID-VkImageCreateInfo-flags-02557
If flags contains VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, imageType must be VK_IMAGE_TYPE_2D
VUID-VkImageCreateInfo-flags-00950
If flags contains VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, imageType must be VK_IMAGE_TYPE_3D
VUID-VkImageCreateInfo-extent-02252
extent.width must be less than or equal to imageCreateMaxExtent.width (as defined in Image Creation Limits).
VUID-VkImageCreateInfo-extent-02253
extent.height must be less than or equal to imageCreateMaxExtent.height (as defined in Image Creation Limits).
VUID-VkImageCreateInfo-extent-02254
extent.depth must be less than or equal to imageCreateMaxExtent.depth (as defined in Image Creation Limits).
VUID-VkImageCreateInfo-imageType-00954
If imageType is VK_IMAGE_TYPE_2D and flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, extent.width and extent.height must be equal and arrayLayers must be greater than or equal to 6
VUID-VkImageCreateInfo-imageType-00956
If imageType is VK_IMAGE_TYPE_1D, both extent.height and extent.depth must be 1
VUID-VkImageCreateInfo-imageType-00957
If imageType is VK_IMAGE_TYPE_2D, extent.depth must be 1
VUID-VkImageCreateInfo-mipLevels-00958
mipLevels must be less than or equal to the number of levels in the complete mipmap chain based on extent.width, extent.height, and extent.depth.
VUID-VkImageCreateInfo-mipLevels-02255
mipLevels must be less than or equal to imageCreateMaxMipLevels (as defined in Image Creation Limits).
VUID-VkImageCreateInfo-arrayLayers-02256
arrayLayers must be less than or equal to imageCreateMaxArrayLayers (as defined in Image Creation Limits).
VUID-VkImageCreateInfo-imageType-00961
If imageType is VK_IMAGE_TYPE_3D, arrayLayers must be 1.
VUID-VkImageCreateInfo-samples-02257
If samples is not VK_SAMPLE_COUNT_1_BIT, then imageType must be VK_IMAGE_TYPE_2D, flags must not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, mipLevels must be equal to 1, and imageCreateMaybeLinear (as defined in Image Creation Limits) must be false,
VUID-VkImageCreateInfo-samples-02558
If samples is not VK_SAMPLE_COUNT_1_BIT, usage must not contain VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT
VUID-VkImageCreateInfo-usage-00963
If usage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, then bits other than VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, and VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT must not be set
VUID-VkImageCreateInfo-usage-00964
If usage includes VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.width must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferWidth
VUID-VkImageCreateInfo-usage-00965
If usage includes VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.height must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferHeight
VUID-VkImageCreateInfo-usage-02559
If usage includes VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, extent.width must be less than or equal to \(\lceil{\frac{maxFramebufferWidth}{minFragmentDensityTexelSize_{width}}}\rceil\)
VUID-VkImageCreateInfo-usage-02560
If usage includes VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, extent.height must be less than or equal to \(\lceil{\frac{maxFramebufferHeight}{minFragmentDensityTexelSize_{height}}}\rceil\)
VUID-VkImageCreateInfo-usage-00966
If usage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, usage must also contain at least one of VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT.
VUID-VkImageCreateInfo-samples-02258
samples must be a bit value that is set in imageCreateSampleCounts (as defined in Image Creation Limits).
VUID-VkImageCreateInfo-usage-00968
If the multisampled storage images feature is not enabled, and usage contains VK_IMAGE_USAGE_STORAGE_BIT, samples must be VK_SAMPLE_COUNT_1_BIT
VUID-VkImageCreateInfo-flags-00969
If the sparse bindings feature is not enabled, flags must not contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT
VUID-VkImageCreateInfo-flags-01924
If the sparse aliased residency feature is not enabled, flags must not contain VK_IMAGE_CREATE_SPARSE_ALIASED_BIT
VUID-VkImageCreateInfo-imageType-00970
If imageType is VK_IMAGE_TYPE_1D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
VUID-VkImageCreateInfo-imageType-00971
If the sparse residency for 2D images feature is not enabled, and imageType is VK_IMAGE_TYPE_2D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
VUID-VkImageCreateInfo-imageType-00972
If the sparse residency for 3D images feature is not enabled, and imageType is VK_IMAGE_TYPE_3D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
VUID-VkImageCreateInfo-imageType-00973
If the sparse residency for images with 2 samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_2_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
VUID-VkImageCreateInfo-imageType-00974
If the sparse residency for images with 4 samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_4_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
VUID-VkImageCreateInfo-imageType-00975
If the sparse residency for images with 8 samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_8_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
VUID-VkImageCreateInfo-imageType-00976
If the sparse residency for images with 16 samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_16_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
VUID-VkImageCreateInfo-flags-00987
If flags contains VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT
VUID-VkImageCreateInfo-None-01925
If any of the bits VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT are set, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT must not also be set
VUID-VkImageCreateInfo-flags-01890
If the protected memory feature is not enabled, flags must not contain VK_IMAGE_CREATE_PROTECTED_BIT.
VUID-VkImageCreateInfo-None-01891
If any of the bits VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT are set, VK_IMAGE_CREATE_PROTECTED_BIT must not also be set.
VUID-VkImageCreateInfo-pNext-00988
If the pNext chain includes a VkExternalMemoryImageCreateInfoNV structure, it must not contain a VkExternalMemoryImageCreateInfo structure.
VUID-VkImageCreateInfo-pNext-00990
If the pNext chain includes a VkExternalMemoryImageCreateInfo structure, its handleTypes member must only contain bits that are also in VkExternalImageFormatProperties::externalMemoryProperties.compatibleHandleTypes, as returned by vkGetPhysicalDeviceImageFormatProperties2 with format, imageType, tiling, usage, and flags equal to those in this structure, and with a VkPhysicalDeviceExternalImageFormatInfo structure included in the pNext chain, with a handleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfo::handleTypes
VUID-VkImageCreateInfo-pNext-00991
If the pNext chain includes a VkExternalMemoryImageCreateInfoNV structure, its handleTypes member must only contain bits that are also in VkExternalImageFormatPropertiesNV::externalMemoryProperties.compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalImageFormatPropertiesNV with format, imageType, tiling, usage, and flags equal to those in this structure, and with externalHandleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfoNV::handleTypes
VUID-VkImageCreateInfo-physicalDeviceCount-01421
If the logical device was created with VkDeviceGroupDeviceCreateInfo::physicalDeviceCount equal to 1, flags must not contain VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT
VUID-VkImageCreateInfo-flags-02259
If flags contains VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, then mipLevels must be one, arrayLayers must be one, imageType must be VK_IMAGE_TYPE_2D. and imageCreateMaybeLinear (as defined in Image Creation Limits) must be false.
VUID-VkImageCreateInfo-flags-01572
If flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, then format must be a block-compressed image format, an ETC compressed image format, or an ASTC compressed image format.
VUID-VkImageCreateInfo-flags-01573
If flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, then flags must also contain VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT.
VUID-VkImageCreateInfo-initialLayout-00993
initialLayout must be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED.
VUID-VkImageCreateInfo-pNext-01443
If the pNext chain includes a VkExternalMemoryImageCreateInfo or VkExternalMemoryImageCreateInfoNV structure whose handleTypes member is not 0, initialLayout must be VK_IMAGE_LAYOUT_UNDEFINED
VUID-VkImageCreateInfo-format-02561
If the image format is one of those listed in Formats requiring sampler Y′C_BC_R conversion for VK_IMAGE_ASPECT_COLOR_BIT image views, then mipLevels must be 1
VUID-VkImageCreateInfo-format-02562
If the image format is one of those listed in Formats requiring sampler Y′C_BC_R conversion for VK_IMAGE_ASPECT_COLOR_BIT image views, samples must be VK_SAMPLE_COUNT_1_BIT
VUID-VkImageCreateInfo-format-02563
If the image format is one of those listed in Formats requiring sampler Y′C_BC_R conversion for VK_IMAGE_ASPECT_COLOR_BIT image views, imageType must be VK_IMAGE_TYPE_2D
VUID-VkImageCreateInfo-format-02653
If the image format is one of those listed in Formats requiring sampler Y′C_BC_R conversion for VK_IMAGE_ASPECT_COLOR_BIT image views, and the ycbcrImageArrays feature is not enabled, arrayLayers must be 1
VUID-VkImageCreateInfo-imageCreateFormatFeatures-02260
If format is a multi-planar format, and if imageCreateFormatFeatures (as defined in Image Creation Limits) does not contain VK_FORMAT_FEATURE_DISJOINT_BIT, then flags must not contain VK_IMAGE_CREATE_DISJOINT_BIT
VUID-VkImageCreateInfo-format-01577
If format is not a multi-planar format, and flags does not include VK_IMAGE_CREATE_ALIAS_BIT, flags must not contain VK_IMAGE_CREATE_DISJOINT_BIT
VUID-VkImageCreateInfo-tiling-02261
If tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then the pNext chain must include exactly one of VkImageDrmFormatModifierListCreateInfoEXT or VkImageDrmFormatModifierExplicitCreateInfoEXT structures
VUID-VkImageCreateInfo-pNext-02262
If the pNext chain includes a VkImageDrmFormatModifierListCreateInfoEXT or VkImageDrmFormatModifierExplicitCreateInfoEXT structure, then tiling must be VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT
VUID-VkImageCreateInfo-tiling-02353
If tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT and flags contains VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, then the pNext chain must include a VkImageFormatListCreateInfo structure with non-zero viewFormatCount.
VUID-VkImageCreateInfo-flags-01533
If flags contains VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT format must be a depth or depth/stencil format
VUID-VkImageCreateInfo-pNext-02393
If the pNext chain includes a VkExternalMemoryImageCreateInfo structure whose handleTypes member includes VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, imageType must be VK_IMAGE_TYPE_2D.
VUID-VkImageCreateInfo-pNext-02394
If the pNext chain includes a VkExternalMemoryImageCreateInfo structure whose handleTypes member includes VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, mipLevels must either be 1 or equal to the number of levels in the complete mipmap chain based on extent.width, extent.height, and extent.depth.
VUID-VkImageCreateInfo-pNext-02396
If the pNext chain includes a VkExternalFormatANDROID structure whose externalFormat member is not 0, flags must not include VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT.
VUID-VkImageCreateInfo-pNext-02397
If the pNext chain includes a VkExternalFormatANDROID structure whose externalFormat member is not 0, usage must not include any usages except VK_IMAGE_USAGE_SAMPLED_BIT.
VUID-VkImageCreateInfo-pNext-02398
If the pNext chain includes a VkExternalFormatANDROID structure whose externalFormat member is not 0, tiling must be VK_IMAGE_TILING_OPTIMAL.
VUID-VkImageCreateInfo-format-02795
If format is a depth-stencil format, usage includes VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, and the pNext chain includes a VkImageStencilUsageCreateInfo structure, then its VkImageStencilUsageCreateInfo::stencilUsage member must also include VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
VUID-VkImageCreateInfo-format-02796
If format is a depth-stencil format, usage does not include VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, and the pNext chain includes a VkImageStencilUsageCreateInfo structure, then its VkImageStencilUsageCreateInfo::stencilUsage member must also not include VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
VUID-VkImageCreateInfo-format-02797
If format is a depth-stencil format, usage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, and the pNext chain includes a VkImageStencilUsageCreateInfo structure, then its VkImageStencilUsageCreateInfo::stencilUsage member must also include VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT
VUID-VkImageCreateInfo-format-02798
If format is a depth-stencil format, usage does not include VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, and the pNext chain includes a VkImageStencilUsageCreateInfo structure, then its VkImageStencilUsageCreateInfo::stencilUsage member must also not include VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT
VUID-VkImageCreateInfo-Format-02536
If Format is a depth-stencil format and the pNext chain includes a VkImageStencilUsageCreateInfo structure with its stencilUsage member including VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.width must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferWidth
VUID-VkImageCreateInfo-format-02537
If format is a depth-stencil format and the pNext chain includes a VkImageStencilUsageCreateInfo structure with its stencilUsage member including VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.height must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferHeight
VUID-VkImageCreateInfo-format-02538
If the multisampled storage images feature is not enabled, format is a depth-stencil format and the pNext chain includes a VkImageStencilUsageCreateInfo structure with its stencilUsage including VK_IMAGE_USAGE_STORAGE_BIT, samples must be VK_SAMPLE_COUNT_1_BIT
VUID-VkImageCreateInfo-flags-02050
If flags contains VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV, imageType must be VK_IMAGE_TYPE_2D or VK_IMAGE_TYPE_3D
VUID-VkImageCreateInfo-flags-02051
If flags contains VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV, it must not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT and the format must not be a depth/stencil format
VUID-VkImageCreateInfo-flags-02052
If flags contains VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV and imageType is VK_IMAGE_TYPE_2D, extent.width and extent.height must be greater than 1
VUID-VkImageCreateInfo-flags-02053
If flags contains VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV and imageType is VK_IMAGE_TYPE_3D, extent.width, extent.height, and extent.depth must be greater than 1
VUID-VkImageCreateInfo-imageType-02082
If usage includes VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, imageType must be VK_IMAGE_TYPE_2D.
VUID-VkImageCreateInfo-samples-02083
If usage includes VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, samples must be VK_SAMPLE_COUNT_1_BIT.
VUID-VkImageCreateInfo-tiling-02084
If usage includes VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, tiling must be VK_IMAGE_TILING_OPTIMAL.
VUID-VkImageCreateInfo-flags-02565
If flags contains VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, tiling must be VK_IMAGE_TILING_OPTIMAL
VUID-VkImageCreateInfo-flags-02566
If flags contains VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, imageType must be VK_IMAGE_TYPE_2D
VUID-VkImageCreateInfo-flags-02567
If flags contains VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, flags must not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT
VUID-VkImageCreateInfo-flags-02568
If flags contains VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, mipLevels must be 1

Valid Usage (Implicit)

VUID-VkImageCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
VUID-VkImageCreateInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationImageCreateInfoNV, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, or VkImageSwapchainCreateInfoKHR
VUID-VkImageCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkImageCreateInfo-flags-parameter
flags must be a valid combination of VkImageCreateFlagBits values
VUID-VkImageCreateInfo-imageType-parameter
imageType must be a valid VkImageType value
VUID-VkImageCreateInfo-format-parameter
format must be a valid VkFormat value
VUID-VkImageCreateInfo-samples-parameter
samples must be a valid VkSampleCountFlagBits value
VUID-VkImageCreateInfo-tiling-parameter
tiling must be a valid VkImageTiling value
VUID-VkImageCreateInfo-usage-parameter
usage must be a valid combination of VkImageUsageFlagBits values
VUID-VkImageCreateInfo-usage-requiredbitmask
usage must not be 0
VUID-VkImageCreateInfo-sharingMode-parameter
sharingMode must be a valid VkSharingMode value
VUID-VkImageCreateInfo-initialLayout-parameter
initialLayout must be a valid VkImageLayout value

The VkImageStencilUsageCreateInfo structure is defined as:

typedef struct VkImageStencilUsageCreateInfo {
    VkStructureType      sType;
    const void*          pNext;
    VkImageUsageFlags    stencilUsage;
} VkImageStencilUsageCreateInfo;

or the equivalent

typedef VkImageStencilUsageCreateInfo VkImageStencilUsageCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
stencilUsage is a bitmask of VkImageUsageFlagBits describing the intended usage of the stencil aspect of the image.

If the pNext chain of VkImageCreateInfo includes a VkImageStencilUsageCreateInfo structure, then that structure includes the usage flags specific to the stencil aspect of the image for an image with a depth-stencil format.

This structure specifies image usages which only apply to the stencil aspect of a depth/stencil format image. When this structure is included in the pNext chain of VkImageCreateInfo, the stencil aspect of the image must only be used as specified by stencilUsage. When this structure is not included in the pNext chain of VkImageCreateInfo, the stencil aspect of an image must only be used as specified VkImageCreateInfo::usage. Use of other aspects of an image are unaffected by this structure.

This structure can also be included in the pNext chain of VkPhysicalDeviceImageFormatInfo2 to query additional capabilities specific to image creation parameter combinations including a separate set of usage flags for the stencil aspect of the image using vkGetPhysicalDeviceImageFormatProperties2. When this structure is not included in the pNext chain of VkPhysicalDeviceImageFormatInfo2 then the implicit value of stencilUsage matches that of VkPhysicalDeviceImageFormatInfo2::usage.

Valid Usage

VUID-VkImageStencilUsageCreateInfo-stencilUsage-02539
If stencilUsage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, it must not include bits other than VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT

Valid Usage (Implicit)

VUID-VkImageStencilUsageCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO
VUID-VkImageStencilUsageCreateInfo-stencilUsage-parameter
stencilUsage must be a valid combination of VkImageUsageFlagBits values
VUID-VkImageStencilUsageCreateInfo-stencilUsage-requiredbitmask
stencilUsage must not be 0

If the pNext chain includes a VkDedicatedAllocationImageCreateInfoNV structure, then that structure includes an enable controlling whether the image will have a dedicated memory allocation bound to it.

The VkDedicatedAllocationImageCreateInfoNV structure is defined as:

typedef struct VkDedicatedAllocationImageCreateInfoNV {
    VkStructureType    sType;
    const void*        pNext;
    VkBool32           dedicatedAllocation;
} VkDedicatedAllocationImageCreateInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
dedicatedAllocation specifies whether the image will have a dedicated allocation bound to it.

Note

Using a dedicated allocation for color and depth/stencil attachments or other large images may improve performance on some devices.

Valid Usage

VUID-VkDedicatedAllocationImageCreateInfoNV-dedicatedAllocation-00994
If dedicatedAllocation is VK_TRUE, VkImageCreateInfo::flags must not include VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT

Valid Usage (Implicit)

VUID-VkDedicatedAllocationImageCreateInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV

To define a set of external memory handle types that may be used as backing store for an image, add a VkExternalMemoryImageCreateInfo structure to the pNext chain of the VkImageCreateInfo structure. The VkExternalMemoryImageCreateInfo structure is defined as:

typedef struct VkExternalMemoryImageCreateInfo {
    VkStructureType                    sType;
    const void*                        pNext;
    VkExternalMemoryHandleTypeFlags    handleTypes;
} VkExternalMemoryImageCreateInfo;

or the equivalent

typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR;

Note

A VkExternalMemoryImageCreateInfo structure must be included in the creation parameters for an image that will be bound to memory that is either exported or imported.

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
handleTypes is a bitmask of VkExternalMemoryHandleTypeFlagBits specifying one or more external memory handle types.

Valid Usage (Implicit)

VUID-VkExternalMemoryImageCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO
VUID-VkExternalMemoryImageCreateInfo-handleTypes-parameter
handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values
VUID-VkExternalMemoryImageCreateInfo-handleTypes-requiredbitmask
handleTypes must not be 0

If the pNext chain includes a VkExternalMemoryImageCreateInfoNV structure, then that structure defines a set of external memory handle types that may be used as backing store for the image.

The VkExternalMemoryImageCreateInfoNV structure is defined as:

typedef struct VkExternalMemoryImageCreateInfoNV {
    VkStructureType                      sType;
    const void*                          pNext;
    VkExternalMemoryHandleTypeFlagsNV    handleTypes;
} VkExternalMemoryImageCreateInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
handleTypes is a bitmask of VkExternalMemoryHandleTypeFlagBitsNV specifying one or more external memory handle types.

Valid Usage (Implicit)

VUID-VkExternalMemoryImageCreateInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV
VUID-VkExternalMemoryImageCreateInfoNV-handleTypes-parameter
handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values

To create an image with an external format, add a VkExternalFormatANDROID structure in the pNext chain of VkImageCreateInfo. VkExternalFormatANDROID is defined as:

typedef struct VkExternalFormatANDROID {
    VkStructureType    sType;
    void*              pNext;
    uint64_t           externalFormat;
} VkExternalFormatANDROID;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
externalFormat is an implementation-defined identifier for the external format

If externalFormat is zero, the effect is as if the VkExternalFormatANDROID structure was not present. Otherwise, the image will have the specified external format.

Valid Usage

VUID-VkExternalFormatANDROID-externalFormat-01894
externalFormat must be 0 or a value returned in the externalFormat member of VkAndroidHardwareBufferFormatPropertiesANDROID by an earlier call to vkGetAndroidHardwareBufferPropertiesANDROID

Valid Usage (Implicit)

VUID-VkExternalFormatANDROID-sType-sType
sType must be VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID

If the pNext chain of VkImageCreateInfo includes a VkImageSwapchainCreateInfoKHR structure, then that structure includes a swapchain handle indicating that the image will be bound to memory from that swapchain.

The VkImageSwapchainCreateInfoKHR structure is defined as:

typedef struct VkImageSwapchainCreateInfoKHR {
    VkStructureType    sType;
    const void*        pNext;
    VkSwapchainKHR     swapchain;
} VkImageSwapchainCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
swapchain is VK_NULL_HANDLE or a handle of a swapchain that the image will be bound to.

Valid Usage

VUID-VkImageSwapchainCreateInfoKHR-swapchain-00995
If swapchain is not VK_NULL_HANDLE, the fields of VkImageCreateInfo must match the implied image creation parameters of the swapchain

Valid Usage (Implicit)

VUID-VkImageSwapchainCreateInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR
VUID-VkImageSwapchainCreateInfoKHR-swapchain-parameter
If swapchain is not VK_NULL_HANDLE, swapchain must be a valid VkSwapchainKHR handle

If the pNext list of VkImageCreateInfo includes a VkImageFormatListCreateInfo structure, then that structure contains a list of all formats that can be used when creating views of this image.

The VkImageFormatListCreateInfo structure is defined as:

typedef struct VkImageFormatListCreateInfo {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           viewFormatCount;
    const VkFormat*    pViewFormats;
} VkImageFormatListCreateInfo;

or the equivalent

typedef VkImageFormatListCreateInfo VkImageFormatListCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
viewFormatCount is the number of entries in the pViewFormats array.
pViewFormats is an array which lists of all formats which can be used when creating views of this image.

If viewFormatCount is zero, pViewFormats is ignored and the image is created as if the VkImageFormatListCreateInfo structure were not included in the pNext list of VkImageCreateInfo.

Valid Usage

VUID-VkImageFormatListCreateInfo-viewFormatCount-01578
If viewFormatCount is not 0, all of the formats in the pViewFormats array must be compatible with the format specified in the format field of VkImageCreateInfo, as described in the compatibility table.
VUID-VkImageFormatListCreateInfo-flags-01579
If VkImageCreateInfo::flags does not contain VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, viewFormatCount must be 0 or 1.
VUID-VkImageFormatListCreateInfo-viewFormatCount-01580
If viewFormatCount is not 0, VkImageCreateInfo::format must be in pViewFormats.

Valid Usage (Implicit)

VUID-VkImageFormatListCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO
VUID-VkImageFormatListCreateInfo-pViewFormats-parameter
If viewFormatCount is not 0, pViewFormats must be a valid pointer to an array of viewFormatCount valid VkFormat values

If the pNext chain of VkImageCreateInfo includes a VkImageDrmFormatModifierListCreateInfoEXT structure, then the image will be created with one of the Linux DRM format modifiers listed in the structure. The choice of modifier is implementation-dependent.

The VkImageDrmFormatModifierListCreateInfoEXT structure is defined as:

typedef struct VkImageDrmFormatModifierListCreateInfoEXT {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           drmFormatModifierCount;
    const uint64_t*    pDrmFormatModifiers;
} VkImageDrmFormatModifierListCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
drmFormatModifierCount is the length of the pDrmFormatModifiers array.
pDrmFormatModifiers is a pointer to an array of Linux DRM format modifiers.

Valid Usage

VUID-VkImageDrmFormatModifierListCreateInfoEXT-pDrmFormatModifiers-02263
Each modifier in pDrmFormatModifiers must be compatible with the parameters in VkImageCreateInfo and its pNext chain, as determined by querying VkPhysicalDeviceImageFormatInfo2 extended with VkPhysicalDeviceImageDrmFormatModifierInfoEXT.

Valid Usage (Implicit)

VUID-VkImageDrmFormatModifierListCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT
VUID-VkImageDrmFormatModifierListCreateInfoEXT-pDrmFormatModifiers-parameter
pDrmFormatModifiers must be a valid pointer to an array of drmFormatModifierCount uint64_t values
VUID-VkImageDrmFormatModifierListCreateInfoEXT-drmFormatModifierCount-arraylength
drmFormatModifierCount must be greater than 0

If the pNext chain of VkImageCreateInfo includes a VkImageDrmFormatModifierExplicitCreateInfoEXT structure, then the image will be created with the Linux DRM format modifier and memory layout defined by the structure.

The VkImageDrmFormatModifierExplicitCreateInfoEXT structure is defined as:

typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT {
    VkStructureType               sType;
    const void*                   pNext;
    uint64_t                      drmFormatModifier;
    uint32_t                      drmFormatModifierPlaneCount;
    const VkSubresourceLayout*    pPlaneLayouts;
} VkImageDrmFormatModifierExplicitCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
drmFormatModifier is the Linux DRM format modifier with which the image will be created.
drmFormatModifierPlaneCount is the number of memory planes in the image (as reported by VkDrmFormatModifierPropertiesEXT) as well as the length of the pPlaneLayouts array.
pPlaneLayouts is a pointer to an array of VkSubresourceLayout structures describing the image’s memory planes.

The i^th member of pPlaneLayouts describes the layout of the image’s i^th memory plane (that is, VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT). In each element of pPlaneLayouts, the implementation must ignore size. The implementation calculates the size of each plane, which the application can query with vkGetImageSubresourceLayout.

When creating an image with VkImageDrmFormatModifierExplicitCreateInfoEXT, it is the application’s responsibility to satisfy all valid usage requirements. However, the implementation must validate that the provided pPlaneLayouts, when combined with the provided drmFormatModifier and other creation parameters in VkImageCreateInfo and its pNext chain, produce a valid image. (This validation is necessarily implementation-dependent and outside the scope of Vulkan, and therefore not described by valid usage requirements). If this validation fails, then vkCreateImage returns VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT.

Valid Usage

VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifier-02264
drmFormatModifier must be compatible with the parameters in VkImageCreateInfo and its pNext chain, as determined by querying VkPhysicalDeviceImageFormatInfo2 extended with VkPhysicalDeviceImageDrmFormatModifierInfoEXT.
VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifierPlaneCount-02265
drmFormatModifierPlaneCount must be equal to the VkDrmFormatModifierPropertiesEXT::drmFormatModifierPlaneCount associated with VkImageCreateInfo::format and drmFormatModifier, as found by querying VkDrmFormatModifierPropertiesListEXT.
VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-size-02267
For each element of pPlaneLayouts, size must be 0
VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-arrayPitch-02268
For each element of pPlaneLayouts, arrayPitch must be 0 if VkImageCreateInfo::arrayLayers is 1.
VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-depthPitch-02269
For each element of pPlaneLayouts, depthPitch must be 0 if VkImageCreateInfo::extent.depth is 1.

Valid Usage (Implicit)

VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT
VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-pPlaneLayouts-parameter
If drmFormatModifierPlaneCount is not 0, pPlaneLayouts must be a valid pointer to an array of drmFormatModifierPlaneCount VkSubresourceLayout structures

Bits which can be set in VkImageCreateInfo::usage, specifying intended usage of an image, are:

typedef enum VkImageUsageFlagBits {
    VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
    VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
    VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
    VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
    VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
    VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
    VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
    VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00000100,
    VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200,
    VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkImageUsageFlagBits;

VK_IMAGE_USAGE_TRANSFER_SRC_BIT specifies that the image can be used as the source of a transfer command.
VK_IMAGE_USAGE_TRANSFER_DST_BIT specifies that the image can be used as the destination of a transfer command.
VK_IMAGE_USAGE_SAMPLED_BIT specifies that the image can be used to create a VkImageView suitable for occupying a VkDescriptorSet slot either of type VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and be sampled by a shader.
VK_IMAGE_USAGE_STORAGE_BIT specifies that the image can be used to create a VkImageView suitable for occupying a VkDescriptorSet slot of type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE.
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT specifies that the image can be used to create a VkImageView suitable for use as a color or resolve attachment in a VkFramebuffer.
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT specifies that the image can be used to create a VkImageView suitable for use as a depth/stencil or depth/stencil resolve attachment in a VkFramebuffer.
VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT specifies that the memory bound to this image will have been allocated with the VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT (see Memory Allocation for more detail). This bit can be set for any image that can be used to create a VkImageView suitable for use as a color, resolve, depth/stencil, or input attachment.
VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT specifies that the image can be used to create a VkImageView suitable for occupying VkDescriptorSet slot of type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; be read from a shader as an input attachment; and be used as an input attachment in a framebuffer.
VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV specifies that the image can be used to create a VkImageView suitable for use as a shading rate image.
VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT specifies that the image can be used to create a VkImageView suitable for use as a fragment density map image.

typedef VkFlags VkImageUsageFlags;

VkImageUsageFlags is a bitmask type for setting a mask of zero or more VkImageUsageFlagBits.

Bits which can be set in VkImageCreateInfo::flags, specifying additional parameters of an image, are:

typedef enum VkImageCreateFlagBits {
    VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
    VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
    VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
    VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
    VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
    VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400,
    VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040,
    VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020,
    VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080,
    VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100,
    VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800,
    VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200,
    VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000,
    VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000,
    VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000,
    VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
    VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
    VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
    VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
    VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT,
    VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT,
    VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkImageCreateFlagBits;

VK_IMAGE_CREATE_SPARSE_BINDING_BIT specifies that the image will be backed using sparse memory binding.
VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT specifies that the image can be partially backed using sparse memory binding. Images created with this flag must also be created with the VK_IMAGE_CREATE_SPARSE_BINDING_BIT flag.
VK_IMAGE_CREATE_SPARSE_ALIASED_BIT specifies 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 VK_IMAGE_CREATE_SPARSE_BINDING_BIT flag
VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT specifies that the image can be used to create a VkImageView with a different format from the image. For multi-planar formats, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT specifies that a VkImageView can be created of a plane of the image.
VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT specifies that the image can be used to create a VkImageView of type VK_IMAGE_VIEW_TYPE_CUBE or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY.
VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT specifies that the image can be used to create a VkImageView of type VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY.
VK_IMAGE_CREATE_PROTECTED_BIT specifies that the image is a protected image.
VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT specifies that the image can be used with a non-zero value of the splitInstanceBindRegionCount member of a VkBindImageMemoryDeviceGroupInfo structure passed into vkBindImageMemory2. This flag also has the effect of making the image use the standard sparse image block dimensions.
VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT specifies that the image having a compressed format can be used to create a VkImageView with an uncompressed format where each texel in the image view corresponds to a compressed texel block of the image.
VK_IMAGE_CREATE_EXTENDED_USAGE_BIT specifies that the image can be created with usage flags that are not supported for the format the image is created with but are supported for at least one format a VkImageView created from the image can have.
VK_IMAGE_CREATE_DISJOINT_BIT specifies that an image with a multi-planar format must have each plane separately bound to memory, rather than having a single memory binding for the whole image; the presence of this bit distinguishes a disjoint image from an image without this bit set.
VK_IMAGE_CREATE_ALIAS_BIT specifies that two images created with the same creation parameters and aliased to the same memory can interpret the contents of the memory consistently with each other, subject to the rules described in the Memory Aliasing section. This flag further specifies that each plane of a disjoint image can share an in-memory non-linear representation with single-plane images, and that a single-plane image can share an in-memory non-linear representation with a plane of a multi-planar disjoint image, according to the rules in Compatible formats of planes of multi-planar formats. If the pNext chain includes a VkExternalMemoryImageCreateInfo or VkExternalMemoryImageCreateInfoNV structure whose handleTypes member is not 0, it is as if VK_IMAGE_CREATE_ALIAS_BIT is set.
VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT specifies that an image with a depth or depth/stencil format can be used with custom sample locations when used as a depth/stencil attachment.
VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV specifies that the image is a corner-sampled image.
VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT specifies that an image can be in a subsampled format which may be more optimal when written as an attachment by a render pass that has a fragment density map attachment. Accessing a subsampled image has additional considerations:
- Image data read as an image sampler is undefined if the sampler was not created with flags containing VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT or was not sampled through the use of a combined image sampler with an immutable sampler in VkDescriptorSetLayoutBinding.
- Image data read with an input attachment is undefined if the contents were not written as an attachment in an earlier subpass of the same render pass.
- Image data read with load operations may be resampled to the fragment density of the render pass.
- Image contents outside of the render area become undefined if the image is stored as a render pass attachment.

See Sparse Resource Features and Sparse Physical Device Features for more details.

typedef VkFlags VkImageCreateFlags;

VkImageCreateFlags is a bitmask type for setting a mask of zero or more VkImageCreateFlagBits.

Possible values of VkImageCreateInfo::imageType, specifying the basic dimensionality of an image, are:

typedef enum VkImageType {
    VK_IMAGE_TYPE_1D = 0,
    VK_IMAGE_TYPE_2D = 1,
    VK_IMAGE_TYPE_3D = 2,
    VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkImageType;

VK_IMAGE_TYPE_1D specifies a one-dimensional image.
VK_IMAGE_TYPE_2D specifies a two-dimensional image.
VK_IMAGE_TYPE_3D specifies a three-dimensional image.

Possible values of VkImageCreateInfo::tiling, specifying the tiling arrangement of texel blocks in an image, are:

typedef enum VkImageTiling {
    VK_IMAGE_TILING_OPTIMAL = 0,
    VK_IMAGE_TILING_LINEAR = 1,
    VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000,
    VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
} VkImageTiling;

VK_IMAGE_TILING_OPTIMAL specifies optimal tiling (texels are laid out in an implementation-dependent arrangement, for more optimal memory access).
VK_IMAGE_TILING_LINEAR specifies linear tiling (texels are laid out in memory in row-major order, possibly with some padding on each row).
VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT indicates that the image’s tiling is defined by a Linux DRM format modifier. The modifier is specified at image creation with VkImageDrmFormatModifierListCreateInfoEXT or VkImageDrmFormatModifierExplicitCreateInfoEXT, and can be queried with vkGetImageDrmFormatModifierPropertiesEXT.

To query the memory layout of an image subresource, call:

void vkGetImageSubresourceLayout(
    VkDevice                                    device,
    VkImage                                     image,
    const VkImageSubresource*                   pSubresource,
    VkSubresourceLayout*                        pLayout);

device is the logical device that owns the image.
image is the image whose layout is being queried.
pSubresource is a pointer to a VkImageSubresource structure selecting a specific image for the image subresource.
pLayout is a pointer to a VkSubresourceLayout structure in which the layout is returned.

If the image is linear, then the returned layout is valid for host access.

If the image’s tiling is VK_IMAGE_TILING_LINEAR and its format is a multi-planar format, then vkGetImageSubresourceLayout describes one format plane of the image. If the image’s tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then vkGetImageSubresourceLayout describes one memory plane of the image. If the image’s tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT and the image is non-linear, then the returned layout has an implementation-dependent meaning; the vendor of the image’s DRM format modifier may provide documentation that explains how to interpret the returned layout.

vkGetImageSubresourceLayout is invariant for the lifetime of a single image. However, the subresource layout of images in Android hardware buffer external memory is not known until the image has been bound to memory, so applications must not call vkGetImageSubresourceLayout for such an image before it has been bound.

Valid Usage

VUID-vkGetImageSubresourceLayout-image-02270
image must have been created with tiling equal to VK_IMAGE_TILING_LINEAR or VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT
VUID-vkGetImageSubresourceLayout-aspectMask-00997
The aspectMask member of pSubresource must only have a single bit set
VUID-vkGetImageSubresourceLayout-mipLevel-01716
The mipLevel member of pSubresource must be less than the mipLevels specified in VkImageCreateInfo when image was created
VUID-vkGetImageSubresourceLayout-arrayLayer-01717
The arrayLayer member of pSubresource must be less than the arrayLayers specified in VkImageCreateInfo when image was created
VUID-vkGetImageSubresourceLayout-format-01581
If the tiling of the image is VK_IMAGE_TILING_LINEAR and its format is a multi-planar format with two planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT
VUID-vkGetImageSubresourceLayout-format-01582
If the tiling of the image is VK_IMAGE_TILING_LINEAR and its format is a multi-planar format with three planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT
VUID-vkGetImageSubresourceLayout-image-01895
If image was created with the VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID external memory handle type, then image must be bound to memory.
VUID-vkGetImageSubresourceLayout-tiling-02271
If the tiling of the image is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT and the index i must be less than the drmFormatModifierPlaneCount associated with the image’s format and drmFormatModifier.

Valid Usage (Implicit)

VUID-vkGetImageSubresourceLayout-device-parameter
device must be a valid VkDevice handle
VUID-vkGetImageSubresourceLayout-image-parameter
image must be a valid VkImage handle
VUID-vkGetImageSubresourceLayout-pSubresource-parameter
pSubresource must be a valid pointer to a valid VkImageSubresource structure
VUID-vkGetImageSubresourceLayout-pLayout-parameter
pLayout must be a valid pointer to a VkSubresourceLayout structure
VUID-vkGetImageSubresourceLayout-image-parent
image must have been created, allocated, or retrieved from device

The VkImageSubresource structure is defined as:

typedef struct VkImageSubresource {
    VkImageAspectFlags    aspectMask;
    uint32_t              mipLevel;
    uint32_t              arrayLayer;
} VkImageSubresource;

aspectMask is a VkImageAspectFlags selecting the image aspect.
mipLevel selects the mipmap level.
arrayLayer selects the array layer.

Valid Usage (Implicit)

VUID-VkImageSubresource-aspectMask-parameter
aspectMask must be a valid combination of VkImageAspectFlagBits values
VUID-VkImageSubresource-aspectMask-requiredbitmask
aspectMask must not be 0

Information about the layout of the image subresource is returned in a VkSubresourceLayout structure:

typedef struct VkSubresourceLayout {
    VkDeviceSize    offset;
    VkDeviceSize    size;
    VkDeviceSize    rowPitch;
    VkDeviceSize    arrayPitch;
    VkDeviceSize    depthPitch;
} VkSubresourceLayout;

offset is the byte offset from the start of the image or the plane where the image subresource begins.
size is the size in bytes of the image subresource. size includes any extra memory that is required based on rowPitch.
rowPitch describes the number of bytes between each row of texels in an image.
arrayPitch describes the number of bytes between each array layer of an image.
depthPitch describes the number of bytes between each slice of 3D image.

If the image is linear, then rowPitch, arrayPitch and depthPitch describe the layout of the image subresource in linear memory. For uncompressed formats, rowPitch is the number of bytes between texels with the same x coordinate in adjacent rows (y coordinates differ by one). arrayPitch is the number of bytes between texels with the same x and y coordinate in adjacent array layers of the image (array layer values differ by one). depthPitch is the number of bytes between texels with the same x and y coordinate in adjacent slices of a 3D image (z coordinates differ by one). Expressed as an addressing formula, the starting byte of a texel in the image subresource has address:

// (x,y,z,layer) are in texel coordinates
address(x,y,z,layer) = layer*arrayPitch + z*depthPitch + y*rowPitch + x*elementSize + offset

For compressed formats, the rowPitch is the number of bytes between compressed texel blocks in adjacent rows. arrayPitch is the number of bytes between compressed texel blocks in adjacent array layers. depthPitch is the number of bytes between compressed texel blocks in adjacent slices of a 3D image.

// (x,y,z,layer) are in compressed texel block coordinates
address(x,y,z,layer) = layer*arrayPitch + z*depthPitch + y*rowPitch + x*compressedTexelBlockByteSize + offset;

The value of arrayPitch is undefined for images that were not created as arrays. depthPitch is defined only for 3D images.

If the image has a single-plane color format and its tiling is VK_IMAGE_TILING_LINEAR , then the aspectMask member of VkImageSubresource must be VK_IMAGE_ASPECT_COLOR_BIT.

If the image has a depth/stencil format and its tiling is VK_IMAGE_TILING_LINEAR , then aspectMask must be either VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT. On implementations that store depth and stencil aspects separately, querying each of these image subresource layouts will return a different offset and size representing the region of memory used for that aspect. On implementations that store depth and stencil aspects interleaved, the same offset and size are returned and represent the interleaved memory allocation.

If the image has a multi-planar format and its tiling is VK_IMAGE_TILING_LINEAR , then the aspectMask member of VkImageSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or (for 3-plane formats only) VK_IMAGE_ASPECT_PLANE_2_BIT. Querying each of these image subresource layouts will return a different offset and size representing the region of memory used for that plane. If the image is disjoint, then the offset is relative to the base address of the plane. If the image is non-disjoint, then the offset is relative to the base address of the image.

If the image’s tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then the aspectMask member of VkImageSubresource must be one of VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT, where the maximum allowed plane index i is defined by the drmFormatModifierPlaneCount associated with the image’s format and modifier. The memory range used by the subresource is described by offset and size. If the image is disjoint, then the offset is relative to the base address of the memory plane. If the image is non-disjoint, then the offset is relative to the base address of the image. If the image is non-linear, then rowPitch, arrayPitch, and depthPitch have an implementation-dependent meaning.

If an image was created with VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then the image has a Linux DRM format modifier. To query the modifier, call:

VkResult vkGetImageDrmFormatModifierPropertiesEXT(
    VkDevice                                    device,
    VkImage                                     image,
    VkImageDrmFormatModifierPropertiesEXT*      pProperties);

device is the logical device that owns the image.
image is the queried image.
pProperties will return properties of the image’s DRM format modifier.

Valid Usage

VUID-vkGetImageDrmFormatModifierPropertiesEXT-image-02272
image must have been created with tiling equal to VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT.

Valid Usage (Implicit)

VUID-vkGetImageDrmFormatModifierPropertiesEXT-device-parameter
device must be a valid VkDevice handle
VUID-vkGetImageDrmFormatModifierPropertiesEXT-image-parameter
image must be a valid VkImage handle
VUID-vkGetImageDrmFormatModifierPropertiesEXT-pProperties-parameter
pProperties must be a valid pointer to a VkImageDrmFormatModifierPropertiesEXT structure
VUID-vkGetImageDrmFormatModifierPropertiesEXT-image-parent
image must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS

The VkImageDrmFormatModifierPropertiesEXT structure is defined as:

typedef struct VkImageDrmFormatModifierPropertiesEXT {
    VkStructureType    sType;
    void*              pNext;
    uint64_t           drmFormatModifier;
} VkImageDrmFormatModifierPropertiesEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
drmFormatModifier returns the image’s Linux DRM format modifier.

If the image was created with VkImageDrmFormatModifierListCreateInfoEXT, then the returned drmFormatModifier must belong to the list of modifiers provided at time of image creation in VkImageDrmFormatModifierListCreateInfoEXT::pDrmFormatModifiers. If the image was created with VkImageDrmFormatModifierExplicitCreateInfoEXT, then the returned drmFormatModifier must be the modifier provided at time of image creation in VkImageDrmFormatModifierExplicitCreateInfoEXT::drmFormatModifier.

Valid Usage (Implicit)

VUID-VkImageDrmFormatModifierPropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT
VUID-VkImageDrmFormatModifierPropertiesEXT-pNext-pNext
pNext must be NULL

To destroy an image, call:

void vkDestroyImage(
    VkDevice                                    device,
    VkImage                                     image,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the image.
image is the image to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyImage-image-01000
All submitted commands that refer to image, either directly or via a VkImageView, must have completed execution
VUID-vkDestroyImage-image-01001
If VkAllocationCallbacks were provided when image was created, a compatible set of callbacks must be provided here
VUID-vkDestroyImage-image-01002
If no VkAllocationCallbacks were provided when image was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyImage-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyImage-image-parameter
If image is not VK_NULL_HANDLE, image must be a valid VkImage handle
VUID-vkDestroyImage-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyImage-image-parent
If image is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to image must be externally synchronized

11.3.1. Image Format Features

Valid usage of a VkImage may be constrained by the image’s format features, defined below. Such constraints are documented in the affected valid usage statement.

If the image was created with VK_IMAGE_TILING_LINEAR, then its set of format features is the value of VkFormatProperties::linearTilingFeatures found by calling vkGetPhysicalDeviceFormatProperties on the same format as VkImageCreateInfo::format.
If the image was created with VK_IMAGE_TILING_OPTIMAL, but without an external format, then its set of format features is the value of VkFormatProperties::optimalTilingFeatures found by calling vkGetPhysicalDeviceFormatProperties on the same format as VkImageCreateInfo::format.
If the image was created with an external format, then its set of format features is the value of VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures found by calling vkGetAndroidHardwareBufferPropertiesANDROID on the Android hardware buffer that was imported to the VkDeviceMemory to which the image is bound.
If the image was created with VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then:
- The image’s DRM format modifier is the value of VkImageDrmFormatModifierListCreateInfoEXT::drmFormatModifier found by calling vkGetImageDrmFormatModifierPropertiesEXT.
- Let VkDrmFormatModifierPropertiesListEXT::pDrmFormatModifierProperties be the array found by calling vkGetPhysicalDeviceFormatProperties2 on the same format as VkImageCreateInfo::format.
- Let VkDrmFormatModifierPropertiesEXT prop be the array element whose drmFormatModifier member is the value of the image’s DRM format modifier.
- Then the image set of format features is the value of prop::drmFormatModifierTilingFeatures.

11.3.2. Corner-Sampled Images

A corner-sampled image is an image where unnormalized texel coordinates are centered on integer values rather than half-integer values.

A corner-sampled image has a number of differences compared to conventional texture image:

Texels are centered on integer coordinates. See Unnormalized Texel Coordinate Operations
Normalized coordinates are scaled using coord * (dim - 1) rather than coord * dim, where dim is the size of one dimension of the image. See normalized texel coordinate transform.
Partial derivatives are scaled using coord * (dim - 1) rather than coord * dim. See Scale Factor Operation.
Calculation of the next higher lod size goes according to ⌈dim / 2⌉ rather than ⌊dim / 2⌋. See Image Miplevel Sizing.
The minimum level size is 2x2 for 2D images and 2x2x2 for 3D images. See Image Miplevel Sizing.

Corner-sampling is only supported for 2D and 3D images. When sampling a corner-sampled image, the sampler addressing mode must be VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE. Corner-sampled images are not supported as cubemaps or depth/stencil images.

11.3.3. Image Miplevel Sizing

A complete mipmap chain is the full set of miplevels, from the largest miplevel provided, down to the minimum miplevel size.

Conventional Images

For conventional images, the dimensions of each successive miplevel, n+1, are:

: width_n+1 = max(⌊width_n/2⌋, 1)
: height_n+1 = max(⌊height_n/2⌋, 1)
: depth_n+1 = max(⌊depth_n/2⌋, 1)

where width_n, height_n, and depth_n are the dimensions of the next larger miplevel, n.

The minimum miplevel size is:

1 for one-dimensional images,
1x1 for two-dimensional images, and
1x1x1 for three-dimensional images.

The number of levels in a complete mipmap chain is:

: ⌊log₂(max(width₀, height₀, depth₀))⌋ + 1

where width₀, height₀, and depth₀ are the dimensions of the largest (most detailed) miplevel, 0.

Corner-Sampled Images

For corner-sampled images, the dimensions of each successive miplevel, n+1, are:

: width_n+1 = max(⌈width_n/2⌉, 2)
: height_n+1 = max(⌈height_n/2⌉, 2)
: depth_n+1 = max(⌈depth_n/2⌉, 2)

where width_n, height_n, and depth_n are the dimensions of the next larger miplevel, n.

The minimum miplevel size is:

2x2 for two-dimensional images, and
2x2x2 for three-dimensional images.

The number of levels in a complete mipmap chain is:

: ⌈log₂(max(width₀, height₀, depth₀))⌉

where width₀, height₀, and depth₀ are the dimensions of the largest (most detailed) miplevel, 0.

11.4. Image Layouts

Images are stored in implementation-dependent opaque layouts in memory. Each layout has limitations on what kinds of operations are supported for image subresources using the layout. At any given time, the data representing an image subresource in memory exists in a particular layout which is determined by the most recent layout transition that was performed on that image subresource. Applications have control over which layout each image subresource uses, and can transition an image subresource from one layout to another. Transitions can happen with an image memory barrier, included as part of a vkCmdPipelineBarrier or a vkCmdWaitEvents command buffer command (see Image Memory Barriers), or as part of a subpass dependency within a render pass (see VkSubpassDependency). The image layout is per-image subresource, and separate image subresources of the same image can be in different layouts at the same time with one exception - depth and stencil aspects of a given image subresource must always be in the same layout.

Note

Each layout may offer optimal performance for a specific usage of image memory. For example, an image with a layout of VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL may provide optimal performance for use as a color attachment, but be unsupported for use in transfer commands. Applications can transition an image subresource from one layout to another in order to achieve optimal performance when the image subresource is used for multiple kinds of operations. After initialization, applications need not use any layout other than the general layout, though this may produce suboptimal performance on some implementations.

Upon creation, all image subresources of an image are initially in the same layout, where that layout is selected by the VkImageCreateInfo::initialLayout member. The initialLayout must be either VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED. If it is VK_IMAGE_LAYOUT_PREINITIALIZED, then the image data can be preinitialized by the host while using this layout, and the transition away from this layout will preserve that data. If it is VK_IMAGE_LAYOUT_UNDEFINED, then the contents of the data are considered to be undefined, and the transition away from this layout is not guaranteed to preserve that data. For either of these initial layouts, any image subresources must be transitioned to another layout before they are accessed by the device.

Host access to image memory is only well-defined for linear images and for image subresources of those images which are currently in either the VK_IMAGE_LAYOUT_PREINITIALIZED or VK_IMAGE_LAYOUT_GENERAL layout. Calling vkGetImageSubresourceLayout for a linear image returns a subresource layout mapping that is valid for either of those image layouts.

The set of image layouts consists of:

typedef enum VkImageLayout {
    VK_IMAGE_LAYOUT_UNDEFINED = 0,
    VK_IMAGE_LAYOUT_GENERAL = 1,
    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
    VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
    VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
    VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
    VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
    VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000,
    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001,
    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000,
    VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001,
    VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002,
    VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003,
    VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
    VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
    VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = 1000164003,
    VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000,
    VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
    VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL,
    VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL,
    VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL,
    VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
} VkImageLayout;

The type(s) of device access supported by each layout are:

VK_IMAGE_LAYOUT_UNDEFINED does not support device access. This layout must only be used as the initialLayout member of VkImageCreateInfo or VkAttachmentDescription, 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.
VK_IMAGE_LAYOUT_PREINITIALIZED does not support device access. This layout must only be used as the initialLayout member of VkImageCreateInfo or VkAttachmentDescription, 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, VK_IMAGE_LAYOUT_PREINITIALIZED is only useful with linear images because there is not a standard layout defined for VK_IMAGE_TILING_OPTIMAL images.
VK_IMAGE_LAYOUT_GENERAL supports all types of device access.
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 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT usage bit enabled.
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL specifies a layout for both the depth and stencil aspects of a depth/stencil format image allowing read and write access as a depth/stencil attachment. It is equivalent to VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL and VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL.
VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL specifies a layout for both the depth and stencil aspects of a depth/stencil format image allowing read only access as a depth/stencil attachment or in shaders. It is equivalent to VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL and VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL.
VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL specifies a layout for depth/stencil format images allowing read and write access to the stencil aspect as a stencil attachment, and read only access to the depth aspect as a depth attachment or in shaders. It is equivalent to VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL and VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL.
VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL specifies a layout for depth/stencil format images allowing read and write access to the depth aspect as a depth attachment, and read only access to the stencil aspect as a stencil attachment or in shaders. It is equivalent to VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL and VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL.
VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL specifies a layout for the depth aspect of a depth/stencil format image allowing read and write access as a depth attachment.
VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL specifies a layout for the depth aspect of a depth/stencil format image allowing read-only access as a depth attachment or in shaders.
VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL specifies a layout for the stencil aspect of a depth/stencil format image allowing read and write access as a stencil attachment.
VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL specifies a layout for the stencil aspect of a depth/stencil format image allowing read-only access as a stencil attachment or in shaders.
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 VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT usage bit enabled.
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL must only be used as a source image of a transfer command (see the definition of VK_PIPELINE_STAGE_TRANSFER_BIT). This layout is valid only for image subresources of images created with the VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage bit enabled.
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 VK_IMAGE_USAGE_TRANSFER_DST_BIT usage bit enabled.
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR must only be used for presenting a presentable image for display. A swapchain’s image must be transitioned to this layout before calling vkQueuePresentKHR, and must be transitioned away from this layout after calling vkAcquireNextImageKHR.
VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR is valid only for shared presentable images, and must be used for any usage the image supports.
VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV must only be used as a read-only shading-rate-image. This layout is valid only for image subresources of images created with the VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV usage bit enabled.
VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT must only be used as a fragment density map attachment in a VkRenderPass. This layout is valid only for image subresources of images created with the VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT usage bit enabled.

The layout of each image subresource is not a state of the image subresource itself, but is rather a property of how the data in memory is organized, and thus for each mechanism of accessing an image in the API the application must specify a parameter or structure member that indicates which image layout the image subresource(s) are considered to be in when the image will be accessed. For transfer commands, this is a parameter to the command (see Clear Commands and Copy Commands). For use as a framebuffer attachment, this is a member in the substructures of the VkRenderPassCreateInfo (see Render Pass). For use in a descriptor set, this is a member in the VkDescriptorImageInfo structure (see Descriptor Set Updates).

11.4.1. Image Layout Matching Rules

At the time that any command buffer command accessing an image executes on any queue, the layouts of the image subresources that are accessed must all match exactly the layout specified via the API controlling those accesses , except in case of accesses to an image with a depth/stencil format performed through descriptors referring to only a single aspect of the image, where the following relaxed matching rules apply:

Descriptors referring just to the depth aspect of a depth/stencil image only need to match in the image layout of the depth aspect, thus VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL and VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL are considered to match.
Descriptors referring just to the stencil aspect of a depth/stencil image only need to match in the image layout of the stencil aspect, thus VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL and VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL are considered to match .

When performing a layout transition on an image subresource, the old layout value must either equal the current layout of the image subresource (at the time the transition executes), or else be VK_IMAGE_LAYOUT_UNDEFINED (implying that the contents of the image subresource need not be preserved). The new layout used in a transition must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED.

The image layout of each image subresource of a depth/stencil image created with VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT is dependent on the last sample locations used to render to the image subresource as a depth/stencil attachment, thus applications must provide the same sample locations that were last used to render to the given image subresource whenever a layout transition of the image subresource happens, otherwise the contents of the depth aspect of the image subresource become undefined.

In addition, depth reads from a depth/stencil attachment referring to an image subresource range of a depth/stencil image created with VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT using different sample locations than what have been last used to perform depth writes to the image subresources of the same image subresource range return undefined values.

Similarly, depth writes to a depth/stencil attachment referring to an image subresource range of a depth/stencil image created with VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT using different sample locations than what have been last used to perform depth writes to the image subresources of the same image subresource range make the contents of the depth aspect of those image subresources undefined.

11.5. Image Views

Image objects are not directly accessed by pipeline shaders for reading or writing image data. Instead, image views representing contiguous ranges of the image subresources and containing additional metadata are used for that purpose. Views must be created on images of compatible types, and must represent a valid subset of image subresources.

Image views are represented by VkImageView handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)

The types of image views that can be created are:

typedef enum VkImageViewType {
    VK_IMAGE_VIEW_TYPE_1D = 0,
    VK_IMAGE_VIEW_TYPE_2D = 1,
    VK_IMAGE_VIEW_TYPE_3D = 2,
    VK_IMAGE_VIEW_TYPE_CUBE = 3,
    VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
    VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
    VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
    VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkImageViewType;

The exact image view type is partially implicit, based on the image’s type and sample count, as well as the view creation parameters as described in the image view compatibility table for vkCreateImageView. This table also shows which SPIR-V OpTypeImage Dim and Arrayed parameters correspond to each image view type.

To create an image view, call:

VkResult vkCreateImageView(
    VkDevice                                    device,
    const VkImageViewCreateInfo*                pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkImageView*                                pView);

device is the logical device that creates the image view.
pCreateInfo is a pointer to a VkImageViewCreateInfo structure containing parameters to be used to create the image view.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pView is a pointer to a VkImageView handle in which the resulting image view object is returned.

Valid Usage (Implicit)

VUID-vkCreateImageView-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateImageView-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkImageViewCreateInfo structure
VUID-vkCreateImageView-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateImageView-pView-parameter
pView must be a valid pointer to a VkImageView handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkImageViewCreateInfo structure is defined as:

typedef struct VkImageViewCreateInfo {
    VkStructureType            sType;
    const void*                pNext;
    VkImageViewCreateFlags     flags;
    VkImage                    image;
    VkImageViewType            viewType;
    VkFormat                   format;
    VkComponentMapping         components;
    VkImageSubresourceRange    subresourceRange;
} VkImageViewCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkImageViewCreateFlagBits describing additional parameters of the image view.
image is a VkImage on which the view will be created.
viewType is a VkImageViewType value specifying the type of the image view.
format is a VkFormat describing the format and type used to interpret texel blocks in the image.
components is a VkComponentMapping specifies a remapping of color components (or of depth or stencil components after they have been converted into color components).
subresourceRange is a VkImageSubresourceRange selecting the set of mipmap levels and array layers to be accessible to the view.

Some of the image creation parameters are inherited by the view. In particular, image view creation inherits the implicit parameter usage specifying the allowed usages of the image view that, by default, takes the value of the corresponding usage parameter specified in VkImageCreateInfo at image creation time. If the image was has a depth-stencil format and was created with a VkImageStencilUsageCreateInfo structure included in the pNext chain of VkImageCreateInfo, the usage is calculated based on the subresource.aspectMask provided:

If aspectMask includes only VK_IMAGE_ASPECT_STENCIL_BIT, the implicit usage is equal to VkImageStencilUsageCreateInfo::stencilUsage.
If aspectMask includes only VK_IMAGE_ASPECT_DEPTH_BIT, the implicit usage is equal to VkImageCreateInfo::usage.
If both aspects are included in aspectMask, the implicit usage is equal to the intersection of VkImageCreateInfo::usage and VkImageStencilUsageCreateInfo::stencilUsage. The implicit usage can be overriden by adding a VkImageViewUsageCreateInfo structure to the pNext chain.

If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, and if the format of the image is not multi-planar, format can be different from the image’s format, but if image was created without the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag and they are not equal they must be compatible. Image format compatibility is defined in the Format Compatibility Classes section. Views of compatible formats will have the same mapping between texel coordinates and memory locations irrespective of the format, with only the interpretation of the bit pattern changing.

Note

Values intended to be used with one view format may not be exactly preserved when written or read through a different format. For example, an integer value that happens to have the bit pattern of a floating point denorm or NaN may be flushed or canonicalized when written or read through a view with a floating point format. Similarly, a value written through a signed normalized format that has a bit pattern exactly equal to -2^b may be changed to -2^b + 1 as described in Conversion from Normalized Fixed-Point to Floating-Point.

If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, format must be compatible with the image’s format as described above, or must be an uncompressed format in which case it must be size-compatible with the image’s format, as defined for copying data between images In this case the resulting image view’s texel dimensions equal the dimensions of the selected mip level divided by the compressed texel block size and rounded up.

If the image view is to be used with a sampler which supports sampler Y′C_BC_R conversion, an identically defined object of type VkSamplerYcbcrConversion to that used to create the sampler must be passed to vkCreateImageView in a VkSamplerYcbcrConversionInfo included in the pNext chain of VkImageViewCreateInfo. Conversely, if a VkSamplerYcbcrConversion object is passed to vkCreateImageView, an identically defined VkSamplerYcbcrConversion object must be used when sampling the image.

If the image has a multi-planar format and subresourceRange.aspectMask is VK_IMAGE_ASPECT_COLOR_BIT, format must be identical to the image format, and the sampler to be used with the image view must enable sampler Y′C_BC_R conversion.

If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT and the image has a multi-planar format, and if subresourceRange.aspectMask is VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT, format must be compatible with the corresponding plane of the image, and the sampler to be used with the image view must not enable sampler Y′C_BC_R conversion. The width and height of the single-plane image view must be derived from the multi-planar image’s dimensions in the manner listed for plane compatibility for the plane.

Any view of an image plane will have the same mapping between texel coordinates and memory locations as used by the channels of the color aspect, subject to the formulae relating texel coordinates to lower-resolution planes as described in Chroma Reconstruction. That is, if an R or B plane has a reduced resolution relative to the G plane of the multi-planar image, the image view operates using the (u_plane, v_plane) unnormalized coordinates of the reduced-resolution plane, and these coordinates access the same memory locations as the (u_color, v_color) unnormalized coordinates of the color aspect for which chroma reconstruction operations operate on the same (u_plane, v_plane) or (i_plane, j_plane) coordinates.

Table 15. Image and image view parameter compatibility requirements
Dim, Arrayed, MS	Image parameters	View parameters
	`imageType` = ci.`imageType` `width` = ci.`extent.width` `height` = ci.`extent.height` `depth` = ci.`extent.depth` `arrayLayers` = ci.`arrayLayers` `samples` = ci.`samples` `flags` = ci.`flags` where ci is the VkImageCreateInfo used to create `image`.	`baseArrayLayer`, `layerCount`, and `levelCount` are members of the `subresourceRange` member.
1D, 0, 0	`imageType` = `VK_IMAGE_TYPE_1D` `width` ≥ 1 `height` = 1 `depth` = 1 `arrayLayers` ≥ 1 `samples` = 1	`viewType` = `VK_IMAGE_VIEW_TYPE_1D` `baseArrayLayer` ≥ 0 `layerCount` = 1
1D, 1, 0	`imageType` = `VK_IMAGE_TYPE_1D` `width` ≥ 1 `height` = 1 `depth` = 1 `arrayLayers` ≥ 1 `samples` = 1	`viewType` = `VK_IMAGE_VIEW_TYPE_1D_ARRAY` `baseArrayLayer` ≥ 0 `layerCount` ≥ 1
2D, 0, 0	`imageType` = `VK_IMAGE_TYPE_2D` `width` ≥ 1 `height` ≥ 1 `depth` = 1 `arrayLayers` ≥ 1 `samples` = 1	`viewType` = `VK_IMAGE_VIEW_TYPE_2D` `baseArrayLayer` ≥ 0 `layerCount` = 1
2D, 1, 0	`imageType` = `VK_IMAGE_TYPE_2D` `width` ≥ 1 `height` ≥ 1 `depth` = 1 `arrayLayers` ≥ 1 `samples` = 1	`viewType` = `VK_IMAGE_VIEW_TYPE_2D_ARRAY` `baseArrayLayer` ≥ 0 `layerCount` ≥ 1
2D, 0, 1	`imageType` = `VK_IMAGE_TYPE_2D` `width` ≥ 1 `height` ≥ 1 `depth` = 1 `arrayLayers` ≥ 1 `samples` > 1	`viewType` = `VK_IMAGE_VIEW_TYPE_2D` `baseArrayLayer` ≥ 0 `layerCount` = 1
2D, 1, 1	`imageType` = `VK_IMAGE_TYPE_2D` `width` ≥ 1 `height` ≥ 1 `depth` = 1 `arrayLayers` ≥ 1 `samples` > 1	`viewType` = `VK_IMAGE_VIEW_TYPE_2D_ARRAY` `baseArrayLayer` ≥ 0 `layerCount` ≥ 1
CUBE, 0, 0	`imageType` = `VK_IMAGE_TYPE_2D` `width` ≥ 1 `height` = `width` `depth` = 1 `arrayLayers` ≥ 6 `samples` = 1 `flags` includes `VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT`	`viewType` = `VK_IMAGE_VIEW_TYPE_CUBE` `baseArrayLayer` ≥ 0 `layerCount` = 6
CUBE, 1, 0	`imageType` = `VK_IMAGE_TYPE_2D` `width` ≥ 1 `height` = width `depth` = 1 N ≥ 1 `arrayLayers` ≥ 6 × N `samples` = 1 `flags` includes `VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT`	`viewType` = `VK_IMAGE_VIEW_TYPE_CUBE_ARRAY` `baseArrayLayer` ≥ 0 `layerCount` = 6 × N, N ≥ 1
3D, 0, 0	`imageType` = `VK_IMAGE_TYPE_3D` `width` ≥ 1 `height` ≥ 1 `depth` ≥ 1 `arrayLayers` = 1 `samples` = 1	`viewType` = `VK_IMAGE_VIEW_TYPE_3D` `baseArrayLayer` = 0 `layerCount` = 1
3D, 0, 0	`imageType` = `VK_IMAGE_TYPE_3D` `width` ≥ 1 `height` ≥ 1 `depth` ≥ 1 `arrayLayers` = 1 `samples` = 1 `flags` includes `VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT` `flags` does not include `VK_IMAGE_CREATE_SPARSE_BINDING_BIT`, `VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT`, and `VK_IMAGE_CREATE_SPARSE_ALIASED_BIT`	`viewType` = `VK_IMAGE_VIEW_TYPE_2D` `levelCount` = 1 `baseArrayLayer` ≥ 0 `layerCount` = 1
3D, 0, 0	`imageType` = `VK_IMAGE_TYPE_3D` `width` ≥ 1 `height` ≥ 1 `depth` ≥ 1 `arrayLayers` = 1 `samples` = 1 `flags` includes `VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT` `flags` does not include `VK_IMAGE_CREATE_SPARSE_BINDING_BIT`, `VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT`, and `VK_IMAGE_CREATE_SPARSE_ALIASED_BIT`	`viewType` = `VK_IMAGE_VIEW_TYPE_2D_ARRAY` `levelCount` = 1 `baseArrayLayer` ≥ 0 `layerCount` ≥ 1

Valid Usage

VUID-VkImageViewCreateInfo-image-01003
If image was not created with VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT then viewType must not be VK_IMAGE_VIEW_TYPE_CUBE or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
VUID-VkImageViewCreateInfo-viewType-01004
If the image cubemap arrays feature is not enabled, viewType must not be VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
VUID-VkImageViewCreateInfo-image-01005
If image was created with VK_IMAGE_TYPE_3D but without VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set then viewType must not be VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY
VUID-VkImageViewCreateInfo-image-02570
image must have been created with a usage value containing at least one of VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, or VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT
VUID-VkImageViewCreateInfo-None-02273
The format features of the resultant image view must contain at least one bit.
VUID-VkImageViewCreateInfo-usage-02274
If usage contains VK_IMAGE_USAGE_SAMPLED_BIT, then the format features of the resultant image view must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT.
VUID-VkImageViewCreateInfo-usage-02275
If usage contains VK_IMAGE_USAGE_STORAGE_BIT, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT.
VUID-VkImageViewCreateInfo-usage-02276
If usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, then the image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT.
VUID-VkImageViewCreateInfo-usage-02277
If usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, then the image view’s format features must contain VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT.
VUID-VkImageViewCreateInfo-usage-02652
If usage contains VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, then the image view’s format features must contain at least one of VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT or VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT.
VUID-VkImageViewCreateInfo-subresourceRange-01478
subresourceRange.baseMipLevel must be less than the mipLevels specified in VkImageCreateInfo when image was created
VUID-VkImageViewCreateInfo-subresourceRange-01718
If subresourceRange.levelCount is not VK_REMAINING_MIP_LEVELS, subresourceRange.baseMipLevel + subresourceRange.levelCount must be less than or equal to the mipLevels specified in VkImageCreateInfo when image was created
VUID-VkImageViewCreateInfo-image-02571
If image was created with usage containing VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, subresourceRange.levelCount must be 1
VUID-VkImageViewCreateInfo-image-01482
If image is not a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, or viewType is not VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange.baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created
VUID-VkImageViewCreateInfo-subresourceRange-01483
If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, image is not a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, or viewType is not VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange.layerCount must be non-zero and subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created
VUID-VkImageViewCreateInfo-image-02724
If image is a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange.baseArrayLayer must be less than the depth computed from baseMipLevel and extent.depth specified in VkImageCreateInfo when image was created, according to the formula defined in Image Miplevel Sizing.
VUID-VkImageViewCreateInfo-subresourceRange-02725
If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, image is a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange.layerCount must be non-zero and subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the depth computed from baseMipLevel and extent.depth specified in VkImageCreateInfo when image was created, according to the formula defined in Image Miplevel Sizing.
VUID-VkImageViewCreateInfo-image-01018
If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, format must be compatible with the format used to create image, as defined in Format Compatibility Classes
VUID-VkImageViewCreateInfo-image-01761
If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, but without the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, and if the format of the image is not a multi-planar format, format must be compatible with the format used to create image, as defined in Format Compatibility Classes
VUID-VkImageViewCreateInfo-image-01583
If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, format must be compatible with, or must be an uncompressed format that is size-compatible with, the format used to create image.
VUID-VkImageViewCreateInfo-image-01584
If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, the levelCount and layerCount members of subresourceRange must both be 1.
VUID-VkImageViewCreateInfo-pNext-01585
If a VkImageFormatListCreateInfo structure was included in the pNext chain of the VkImageCreateInfo structure used when creating image and the viewFormatCount field of VkImageFormatListCreateInfo is not zero then format must be one of the formats in VkImageFormatListCreateInfo::pViewFormats.
VUID-VkImageViewCreateInfo-image-01586
If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, if the format of the image is a multi-planar format, and if subresourceRange.aspectMask is one of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT, then format must be compatible with the VkFormat for the plane of the image format indicated by subresourceRange.aspectMask, as defined in Compatible formats of planes of multi-planar formats
VUID-VkImageViewCreateInfo-image-01762
If image was not created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, or if the format of the image is a multi-planar format and if subresourceRange.aspectMask is VK_IMAGE_ASPECT_COLOR_BIT, format must be identical to the format used to create image
VUID-VkImageViewCreateInfo-pNext-01970
If the pNext chain includes a VkSamplerYcbcrConversionInfo structure with a conversion value other than VK_NULL_HANDLE, all members of components must have the value VK_COMPONENT_SWIZZLE_IDENTITY.
VUID-VkImageViewCreateInfo-image-01020
If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-VkImageViewCreateInfo-subResourceRange-01021
subresourceRange and viewType must be compatible with the image, as described in the compatibility table
VUID-VkImageViewCreateInfo-image-02399
If image has an external format, format must be VK_FORMAT_UNDEFINED.
VUID-VkImageViewCreateInfo-image-02400
If image has an external format, the pNext chain must include a VkSamplerYcbcrConversionInfo structure with a conversion object created with the same external format as image.
VUID-VkImageViewCreateInfo-image-02401
If image has an external format, all members of components must be VK_COMPONENT_SWIZZLE_IDENTITY.
VUID-VkImageViewCreateInfo-image-02086
If image was created with usage containing VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, viewType must be VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY
VUID-VkImageViewCreateInfo-image-02087
If image was created with usage containing VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, format must be VK_FORMAT_R8_UINT
VUID-VkImageViewCreateInfo-flags-02572
If dynamic fragment density map feature is not enabled, flags must not contain VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT
VUID-VkImageViewCreateInfo-image-02573
If dynamic fragment density map feature is not enabled and image was created with usage containing VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, flags must not contain any of VK_IMAGE_CREATE_PROTECTED_BIT, VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT
VUID-VkImageViewCreateInfo-pNext-02662
If the pNext chain includes a VkImageViewUsageCreateInfo structure, and image was not created with a VkImageStencilUsageCreateInfo structure included in the pNext chain of VkImageCreateInfo, its usage member must not include any bits that were not set in the usage member of the VkImageCreateInfo structure used to create image
VUID-VkImageViewCreateInfo-pNext-02663
If the pNext chain includes a VkImageViewUsageCreateInfo structure, image was created with a VkImageStencilUsageCreateInfo structure included in the pNext chain of VkImageCreateInfo, and subResourceRange.aspectMask includes VK_IMAGE_ASPECT_STENCIL_BIT, the usage member of the VkImageViewUsageCreateInfo instance must not include any bits that were not set in the usage member of the VkImageStencilUsageCreateInfo structure used to create image
VUID-VkImageViewCreateInfo-pNext-02664
If the pNext chain includes a VkImageViewUsageCreateInfo structure, image was created with a VkImageStencilUsageCreateInfo structure included in the pNext chain of VkImageCreateInfo, and subResourceRange.aspectMask includes bits other than VK_IMAGE_ASPECT_STENCIL_BIT, the usage member of the VkImageViewUsageCreateInfo structure must not include any bits that were not set in the usage member of the VkImageCreateInfo structure used to create image

Valid Usage (Implicit)

VUID-VkImageViewCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
VUID-VkImageViewCreateInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkImageViewASTCDecodeModeEXT, VkImageViewUsageCreateInfo, or VkSamplerYcbcrConversionInfo
VUID-VkImageViewCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkImageViewCreateInfo-flags-parameter
flags must be a valid combination of VkImageViewCreateFlagBits values
VUID-VkImageViewCreateInfo-image-parameter
image must be a valid VkImage handle
VUID-VkImageViewCreateInfo-viewType-parameter
viewType must be a valid VkImageViewType value
VUID-VkImageViewCreateInfo-format-parameter
format must be a valid VkFormat value
VUID-VkImageViewCreateInfo-components-parameter
components must be a valid VkComponentMapping structure
VUID-VkImageViewCreateInfo-subresourceRange-parameter
subresourceRange must be a valid VkImageSubresourceRange structure

Bits which can be set in VkImageViewCreateInfo::flags, specifying additional parameters of an image, are:

typedef enum VkImageViewCreateFlagBits {
    VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001,
    VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkImageViewCreateFlagBits;

VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT prohibits the implementation from accessing the fragment density map by the host during vkCmdBeginRenderPass as the contents are expected to change after recording

typedef VkFlags VkImageViewCreateFlags;

VkImageViewCreateFlags is a bitmask type for setting a mask of zero or more VkImageViewCreateFlagBits.

The set of usages for the created image view can be restricted compared to the parent image’s usage flags by adding a VkImageViewUsageCreateInfo structure to the pNext chain of VkImageViewCreateInfo.

The VkImageViewUsageCreateInfo structure is defined as:

typedef struct VkImageViewUsageCreateInfo {
    VkStructureType      sType;
    const void*          pNext;
    VkImageUsageFlags    usage;
} VkImageViewUsageCreateInfo;

or the equivalent

typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
usage is a bitmask describing the allowed usages of the image view. See VkImageUsageFlagBits for a description of the supported bits.

When this structure is chained to VkImageViewCreateInfo the usage field overrides the implicit usage parameter inherited from image creation time and its value is used instead for the purposes of determining the valid usage conditions of VkImageViewCreateInfo.

Valid Usage (Implicit)

VUID-VkImageViewUsageCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO
VUID-VkImageViewUsageCreateInfo-usage-parameter
usage must be a valid combination of VkImageUsageFlagBits values
VUID-VkImageViewUsageCreateInfo-usage-requiredbitmask
usage must not be 0

The VkImageSubresourceRange structure is defined as:

typedef struct VkImageSubresourceRange {
    VkImageAspectFlags    aspectMask;
    uint32_t              baseMipLevel;
    uint32_t              levelCount;
    uint32_t              baseArrayLayer;
    uint32_t              layerCount;
} VkImageSubresourceRange;

aspectMask is a bitmask of VkImageAspectFlagBits specifying which aspect(s) of the image are included in the view.
baseMipLevel is the first mipmap level accessible to the view.
levelCount is the number of mipmap levels (starting from baseMipLevel) accessible to the view.
baseArrayLayer is the first array layer accessible to the view.
layerCount is the number of array layers (starting from baseArrayLayer) accessible to the view.

The number of mipmap levels and array layers must be a subset of the image subresources in the image. If an application wants to use all mip levels or layers in an image after the baseMipLevel or baseArrayLayer, it can set levelCount and layerCount to the special values VK_REMAINING_MIP_LEVELS and VK_REMAINING_ARRAY_LAYERS without knowing the exact number of mip levels or layers.

For cube and cube array image views, the layers of the image view starting at baseArrayLayer correspond to faces in the order +X, -X, +Y, -Y, +Z, -Z. For cube arrays, each set of six sequential layers is a single cube, so the number of cube maps in a cube map array view is layerCount / 6, and image array layer (baseArrayLayer + i) is face index (i mod 6) of cube i / 6. If the number of layers in the view, whether set explicitly in layerCount or implied by VK_REMAINING_ARRAY_LAYERS, is not a multiple of 6, the last cube map in the array must not be accessed.

aspectMask must be only VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT if format is a color, depth-only or stencil-only format, respectively, except if format is a multi-planar format. If using a depth/stencil format with both depth and stencil components, aspectMask must include at least one of VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT, and can include both.

When the VkImageSubresourceRange structure is used to select a subset of the slices of a 3D image’s mip level in order to create a 2D or 2D array image view of a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, baseArrayLayer and layerCount specify the first slice index and the number of slices to include in the created image view. Such an image view can be used as a framebuffer attachment that refers only to the specified range of slices of the selected mip level. However, any layout transitions performed on such an attachment view during a render pass instance still apply to the entire subresource referenced which includes all the slices of the selected mip level.

When using an image view of a depth/stencil image to populate a descriptor set (e.g. for sampling in the shader, or for use as an input attachment), the aspectMask must only include one bit and selects whether the image view is used for depth reads (i.e. using a floating-point sampler or input attachment in the shader) or stencil reads (i.e. using an unsigned integer sampler or input attachment in the shader). When an image view of a depth/stencil image is used as a depth/stencil framebuffer attachment, the aspectMask is ignored and both depth and stencil image subresources are used.

The VkComponentMapping components member describes a remapping from components of the image to components of the vector returned by shader image instructions. This remapping must be identity for storage image descriptors, input attachment descriptors, framebuffer attachments, and any VkImageView used with a combined image sampler that enables sampler Y′C_BC_R conversion.

When creating a VkImageView, if sampler Y′C_BC_R conversion is enabled in the sampler, the aspectMask of a subresourceRange used by the VkImageView must be VK_IMAGE_ASPECT_COLOR_BIT.

When creating a VkImageView, if sampler Y′C_BC_R conversion is not enabled in the sampler and the image format is multi-planar, the image must have been created with VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, and the aspectMask of the VkImageView’s subresourceRange must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT.

Valid Usage

VUID-VkImageSubresourceRange-levelCount-01720
If levelCount is not VK_REMAINING_MIP_LEVELS, it must be greater than 0
VUID-VkImageSubresourceRange-layerCount-01721
If layerCount is not VK_REMAINING_ARRAY_LAYERS, it must be greater than 0
VUID-VkImageSubresourceRange-aspectMask-01670
If aspectMask includes VK_IMAGE_ASPECT_COLOR_BIT, then it must not include any of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT
VUID-VkImageSubresourceRange-aspectMask-02278
aspectMask must not include VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT for any index i

Valid Usage (Implicit)

VUID-VkImageSubresourceRange-aspectMask-parameter
aspectMask must be a valid combination of VkImageAspectFlagBits values
VUID-VkImageSubresourceRange-aspectMask-requiredbitmask
aspectMask must not be 0

Bits which can be set in an aspect mask to specify aspects of an image for purposes such as identifying a subresource, are:

typedef enum VkImageAspectFlagBits {
    VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
    VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
    VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
    VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
    VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010,
    VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020,
    VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040,
    VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080,
    VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100,
    VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200,
    VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400,
    VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT,
    VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT,
    VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT,
    VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkImageAspectFlagBits;

VK_IMAGE_ASPECT_COLOR_BIT specifies the color aspect.
VK_IMAGE_ASPECT_DEPTH_BIT specifies the depth aspect.
VK_IMAGE_ASPECT_STENCIL_BIT specifies the stencil aspect.
VK_IMAGE_ASPECT_METADATA_BIT specifies the metadata aspect, used for sparse sparse resource operations.
VK_IMAGE_ASPECT_PLANE_0_BIT specifies plane 0 of a multi-planar image format.
VK_IMAGE_ASPECT_PLANE_1_BIT specifies plane 1 of a multi-planar image format.
VK_IMAGE_ASPECT_PLANE_2_BIT specifies plane 2 of a multi-planar image format.
VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT specifies memory plane 0.
VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT specifies memory plane 1.
VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT specifies memory plane 2.
VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT specifies memory plane 3.

typedef VkFlags VkImageAspectFlags;

VkImageAspectFlags is a bitmask type for setting a mask of zero or more VkImageAspectFlagBits.

The VkComponentMapping structure is defined as:

typedef struct VkComponentMapping {
    VkComponentSwizzle    r;
    VkComponentSwizzle    g;
    VkComponentSwizzle    b;
    VkComponentSwizzle    a;
} VkComponentMapping;

r is a VkComponentSwizzle specifying the component value placed in the R component of the output vector.
g is a VkComponentSwizzle specifying the component value placed in the G component of the output vector.
b is a VkComponentSwizzle specifying the component value placed in the B component of the output vector.
a is a VkComponentSwizzle specifying the component value placed in the A component of the output vector.

Valid Usage (Implicit)

VUID-VkComponentMapping-r-parameter
r must be a valid VkComponentSwizzle value
VUID-VkComponentMapping-g-parameter
g must be a valid VkComponentSwizzle value
VUID-VkComponentMapping-b-parameter
b must be a valid VkComponentSwizzle value
VUID-VkComponentMapping-a-parameter
a must be a valid VkComponentSwizzle value

Possible values of the members of VkComponentMapping, specifying the component values placed in each component of the output vector, are:

typedef enum VkComponentSwizzle {
    VK_COMPONENT_SWIZZLE_IDENTITY = 0,
    VK_COMPONENT_SWIZZLE_ZERO = 1,
    VK_COMPONENT_SWIZZLE_ONE = 2,
    VK_COMPONENT_SWIZZLE_R = 3,
    VK_COMPONENT_SWIZZLE_G = 4,
    VK_COMPONENT_SWIZZLE_B = 5,
    VK_COMPONENT_SWIZZLE_A = 6,
    VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
} VkComponentSwizzle;

VK_COMPONENT_SWIZZLE_IDENTITY specifies that the component is set to the identity swizzle.
VK_COMPONENT_SWIZZLE_ZERO specifies that the component is set to zero.
VK_COMPONENT_SWIZZLE_ONE specifies that 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.
VK_COMPONENT_SWIZZLE_R specifies that the component is set to the value of the R component of the image.
VK_COMPONENT_SWIZZLE_G specifies that the component is set to the value of the G component of the image.
VK_COMPONENT_SWIZZLE_B specifies that the component is set to the value of the B component of the image.
VK_COMPONENT_SWIZZLE_A specifies that the component is set to the value of the A component of the image.

Setting the identity swizzle on a component is equivalent to setting the identity mapping on that component. That is:

Table 16. Component Mappings Equivalent To `VK_COMPONENT_SWIZZLE_IDENTITY`
Component	Identity Mapping
`components.r`	`VK_COMPONENT_SWIZZLE_R`
`components.g`	`VK_COMPONENT_SWIZZLE_G`
`components.b`	`VK_COMPONENT_SWIZZLE_B`
`components.a`	`VK_COMPONENT_SWIZZLE_A`

If the pNext list includes a VkImageViewASTCDecodeModeEXT structure, then that structure includes a parameter specifying the decode mode for image views using ASTC compressed formats.

The VkImageViewASTCDecodeModeEXT structure is defined as:

typedef struct VkImageViewASTCDecodeModeEXT {
    VkStructureType    sType;
    const void*        pNext;
    VkFormat           decodeMode;
} VkImageViewASTCDecodeModeEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
decodeMode is the intermediate format used to decode ASTC compressed formats.

Valid Usage

VUID-VkImageViewASTCDecodeModeEXT-decodeMode-02230
decodeMode must be one of VK_FORMAT_R16G16B16A16_SFLOAT, VK_FORMAT_R8G8B8A8_UNORM, or VK_FORMAT_E5B9G9R9_UFLOAT_PACK32
VUID-VkImageViewASTCDecodeModeEXT-decodeMode-02231
If the decodeModeSharedExponent feature is not enabled, decodeMode must not be VK_FORMAT_E5B9G9R9_UFLOAT_PACK32
VUID-VkImageViewASTCDecodeModeEXT-decodeMode-02232
If decodeMode is VK_FORMAT_R8G8B8A8_UNORM the image view must not include blocks using any of the ASTC HDR modes
VUID-VkImageViewASTCDecodeModeEXT-format-02233
format of the image view must be one of VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_FORMAT_ASTC_4x4_SRGB_BLOCK, VK_FORMAT_ASTC_5x4_UNORM_BLOCK, VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_FORMAT_ASTC_5x5_UNORM_BLOCK, VK_FORMAT_ASTC_5x5_SRGB_BLOCK, VK_FORMAT_ASTC_6x5_UNORM_BLOCK, VK_FORMAT_ASTC_6x5_SRGB_BLOCK, VK_FORMAT_ASTC_6x6_UNORM_BLOCK, VK_FORMAT_ASTC_6x6_SRGB_BLOCK, VK_FORMAT_ASTC_8x5_UNORM_BLOCK, VK_FORMAT_ASTC_8x5_SRGB_BLOCK, VK_FORMAT_ASTC_8x6_UNORM_BLOCK, VK_FORMAT_ASTC_8x6_SRGB_BLOCK, VK_FORMAT_ASTC_8x8_UNORM_BLOCK, VK_FORMAT_ASTC_8x8_SRGB_BLOCK, VK_FORMAT_ASTC_10x5_UNORM_BLOCK, VK_FORMAT_ASTC_10x5_SRGB_BLOCK, VK_FORMAT_ASTC_10x6_UNORM_BLOCK, VK_FORMAT_ASTC_10x6_SRGB_BLOCK, VK_FORMAT_ASTC_10x8_UNORM_BLOCK, VK_FORMAT_ASTC_10x8_SRGB_BLOCK, VK_FORMAT_ASTC_10x10_UNORM_BLOCK, VK_FORMAT_ASTC_10x10_SRGB_BLOCK, VK_FORMAT_ASTC_12x10_UNORM_BLOCK, VK_FORMAT_ASTC_12x10_SRGB_BLOCK, VK_FORMAT_ASTC_12x12_UNORM_BLOCK, or VK_FORMAT_ASTC_12x12_SRGB_BLOCK

If format uses sRGB encoding then the decodeMode has no effect.

Valid Usage (Implicit)

VUID-VkImageViewASTCDecodeModeEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT
VUID-VkImageViewASTCDecodeModeEXT-decodeMode-parameter
decodeMode must be a valid VkFormat value

To destroy an image view, call:

void vkDestroyImageView(
    VkDevice                                    device,
    VkImageView                                 imageView,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the image view.
imageView is the image view to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyImageView-imageView-01026
All submitted commands that refer to imageView must have completed execution
VUID-vkDestroyImageView-imageView-01027
If VkAllocationCallbacks were provided when imageView was created, a compatible set of callbacks must be provided here
VUID-vkDestroyImageView-imageView-01028
If no VkAllocationCallbacks were provided when imageView was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyImageView-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyImageView-imageView-parameter
If imageView is not VK_NULL_HANDLE, imageView must be a valid VkImageView handle
VUID-vkDestroyImageView-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyImageView-imageView-parent
If imageView is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to imageView must be externally synchronized

To get the handle for an image view, call:

uint32_t vkGetImageViewHandleNVX(
    VkDevice                                    device,
    const VkImageViewHandleInfoNVX*             pInfo);

device is the logical device that owns the image view.
pInfo describes the image view to query and type of handle.

Valid Usage (Implicit)

VUID-vkGetImageViewHandleNVX-device-parameter
device must be a valid VkDevice handle
VUID-vkGetImageViewHandleNVX-pInfo-parameter
pInfo must be a valid pointer to a valid VkImageViewHandleInfoNVX structure

The VkImageViewHandleInfoNVX structure is defined as:

typedef struct VkImageViewHandleInfoNVX {
    VkStructureType     sType;
    const void*         pNext;
    VkImageView         imageView;
    VkDescriptorType    descriptorType;
    VkSampler           sampler;
} VkImageViewHandleInfoNVX;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
imageView is the image view to query.
descriptorType is the type of descriptor for which to query a handle.
sampler is the sampler to combine with the image view when generating the handle.

Valid Usage

VUID-VkImageViewHandleInfoNVX-descriptorType-02654
descriptorType must be VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
VUID-VkImageViewHandleInfoNVX-sampler-02655
sampler must be a valid VkSampler if descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
VUID-VkImageViewHandleInfoNVX-imageView-02656
If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the image that imageView was created from must have been created with the VK_IMAGE_USAGE_SAMPLED_BIT usage bit set
VUID-VkImageViewHandleInfoNVX-imageView-02657
If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, the image that imageView was created from must have been created with the VK_IMAGE_USAGE_STORAGE_BIT usage bit set

Valid Usage (Implicit)

VUID-VkImageViewHandleInfoNVX-sType-sType
sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX
VUID-VkImageViewHandleInfoNVX-pNext-pNext
pNext must be NULL
VUID-VkImageViewHandleInfoNVX-imageView-parameter
imageView must be a valid VkImageView handle
VUID-VkImageViewHandleInfoNVX-descriptorType-parameter
descriptorType must be a valid VkDescriptorType value
VUID-VkImageViewHandleInfoNVX-sampler-parameter
If sampler is not VK_NULL_HANDLE, sampler must be a valid VkSampler handle
VUID-VkImageViewHandleInfoNVX-commonparent
Both of imageView, and sampler that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

11.5.1. Image View Format Features

Valid usage of a VkImageView may be constrained by the image view’s format features, defined below. Such constraints are documented in the affected valid usage statement.

If the view’s image was created with VK_IMAGE_TILING_LINEAR, then the image view’s set of format features is the value of VkFormatProperties::linearTilingFeatures found by calling vkGetPhysicalDeviceFormatProperties on the same format as VkImageViewCreateInfo::format.
If the view’s image was created with VK_IMAGE_TILING_OPTIMAL, but without an external format, then the image view’s set of format features is the value of VkFormatProperties::optimalTilingFeatures found by calling vkGetPhysicalDeviceFormatProperties on the same format as VkImageViewCreateInfo::format.
If the view’s image was created with an external format, then the image views’s set of format features is the value of VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures found by calling vkGetAndroidHardwareBufferPropertiesANDROID on the Android hardware buffer that was imported to the VkDeviceMemory to which the image is bound.
If the view’s image was created with VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then:
- The image’s DRM format modifier is the value of VkImageDrmFormatModifierListCreateInfoEXT::drmFormatModifier found by calling vkGetImageDrmFormatModifierPropertiesEXT.
- Let VkDrmFormatModifierPropertiesListEXT::pDrmFormatModifierProperties be the array found by calling vkGetPhysicalDeviceFormatProperties2 on the same format as VkImageViewCreateInfo::format.
- Let VkDrmFormatModifierPropertiesEXT prop be the array element whose drmFormatModifier member is the value of the image’s DRM format modifier.
- Then the image view’s set of format features is the value of prop::drmFormatModifierTilingFeatures.

11.6. Resource Memory Association

Resources are initially created as virtual allocations with no backing memory. Device memory is allocated separately (see Device Memory) and then associated with the resource. This association is done differently for sparse and non-sparse resources.

Resources created with any of the sparse creation flags are considered sparse resources. Resources created without these flags are non-sparse. The details on resource memory association for sparse resources is described in Sparse Resources.

Non-sparse resources must be bound completely and contiguously to a single VkDeviceMemory object before the resource is passed as a parameter to any of the following operations:

creating image or buffer views
updating descriptor sets
recording commands in a command buffer

Once bound, the memory binding is immutable for the lifetime of the resource.

In a logical device representing more than one physical device, buffer and image resources exist on all physical devices but can be bound to memory differently on each. Each such replicated resource is an instance of the resource. For sparse resources, each instance can be bound to memory arbitrarily differently. For non-sparse resources, each instance can either be bound to the local or a peer instance of the memory, or for images can be bound to rectangular regions from the local and/or peer instances. When a resource is used in a descriptor set, each physical device interprets the descriptor according to its own instance’s binding to memory.

Note

There are no new copy commands to transfer data between physical devices. Instead, an application can create a resource with a peer mapping and use it as the source or destination of a transfer command executed by a single physical device to copy the data from one physical device to another.

To determine the memory requirements for a buffer resource, call:

void vkGetBufferMemoryRequirements(
    VkDevice                                    device,
    VkBuffer                                    buffer,
    VkMemoryRequirements*                       pMemoryRequirements);

device is the logical device that owns the buffer.
buffer is the buffer to query.
pMemoryRequirements is a pointer to a VkMemoryRequirements structure in which the memory requirements of the buffer object are returned.

Valid Usage (Implicit)

VUID-vkGetBufferMemoryRequirements-device-parameter
device must be a valid VkDevice handle
VUID-vkGetBufferMemoryRequirements-buffer-parameter
buffer must be a valid VkBuffer handle
VUID-vkGetBufferMemoryRequirements-pMemoryRequirements-parameter
pMemoryRequirements must be a valid pointer to a VkMemoryRequirements structure
VUID-vkGetBufferMemoryRequirements-buffer-parent
buffer must have been created, allocated, or retrieved from device

To determine the memory requirements for an image resource which is not created with the VK_IMAGE_CREATE_DISJOINT_BIT flag set, call:

void vkGetImageMemoryRequirements(
    VkDevice                                    device,
    VkImage                                     image,
    VkMemoryRequirements*                       pMemoryRequirements);

device is the logical device that owns the image.
image is the image to query.
pMemoryRequirements is a pointer to a VkMemoryRequirements structure in which the memory requirements of the image object are returned.

Valid Usage

VUID-vkGetImageMemoryRequirements-image-01588
image must not have been created with the VK_IMAGE_CREATE_DISJOINT_BIT flag set

Valid Usage (Implicit)

VUID-vkGetImageMemoryRequirements-device-parameter
device must be a valid VkDevice handle
VUID-vkGetImageMemoryRequirements-image-parameter
image must be a valid VkImage handle
VUID-vkGetImageMemoryRequirements-pMemoryRequirements-parameter
pMemoryRequirements must be a valid pointer to a VkMemoryRequirements structure
VUID-vkGetImageMemoryRequirements-image-parent
image must have been created, allocated, or retrieved from device

The VkMemoryRequirements structure is defined as:

typedef struct VkMemoryRequirements {
    VkDeviceSize    size;
    VkDeviceSize    alignment;
    uint32_t        memoryTypeBits;
} VkMemoryRequirements;

size is the size, in bytes, of the memory allocation required for the resource.
alignment is the alignment, in bytes, of the offset within the allocation required for the resource.
memoryTypeBits is a bitmask and contains one bit set for every supported memory type for the resource. Bit i is set if and only if the memory type i in the VkPhysicalDeviceMemoryProperties structure for the physical device is supported for the resource.

The precise size of images that will be bound to external Android hardware buffer memory is unknown until the memory has been imported or allocated, so applications must not call vkGetImageMemoryRequirements with such an image before it has been bound to memory. When importing Android hardware buffer memory, the allocationSize can be determined by calling vkGetAndroidHardwareBufferPropertiesANDROID. When allocating new memory for an image that can be exported to an Android hardware buffer, the memory’s allocationSize must be zero; the actual size will be determined by the dedicated image’s parameters. After the memory has been allocated, the amount of space allocated from the memory’s heap can be obtained by getting the image’s memory requirements or by calling vkGetAndroidHardwareBufferPropertiesANDROID with the Android hardware buffer exported from the memory.

The implementation guarantees certain properties about the memory requirements returned by vkGetBufferMemoryRequirements and vkGetImageMemoryRequirements:

The memoryTypeBits member always contains at least one bit set.
If buffer is a VkBuffer not created with the VK_BUFFER_CREATE_SPARSE_BINDING_BIT bit set, or if image is linear image, then the memoryTypeBits member always contains at least one bit set corresponding to a VkMemoryType with a propertyFlags that has both the VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT bit and the VK_MEMORY_PROPERTY_HOST_COHERENT_BIT bit set. In other words, mappable coherent memory can always be attached to these objects.
If buffer was created with VkExternalMemoryBufferCreateInfo::handleTypes set to 0 or image was created with VkExternalMemoryImageCreateInfo::handleTypes set to 0, the memoryTypeBits member always contains at least one bit set corresponding to a VkMemoryType with a propertyFlags that has the VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT bit set.
The memoryTypeBits member is identical for all VkBuffer objects created with the same value for the flags and usage members in the VkBufferCreateInfo structure and the handleTypes member of the VkExternalMemoryBufferCreateInfo structure passed to vkCreateBuffer. Further, if usage1 and usage2 of type VkBufferUsageFlags are such that the bits set in usage2 are a subset of the bits set in usage1, and they have the same flags and VkExternalMemoryBufferCreateInfo::handleTypes, then the bits set in memoryTypeBits returned for usage1 must be a subset of the bits set in memoryTypeBits returned for usage2, for all values of flags.
The alignment member is a power of two.
The alignment member is identical for all VkBuffer objects created with the same combination of values for the usage and flags members in the VkBufferCreateInfo structure passed to vkCreateBuffer.
The alignment member satisfies the buffer descriptor offset alignment requirements associated with the VkBuffer’s usage:
- If usage included VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, alignment must be an integer multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment.
- If usage included VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, alignment must be an integer multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment.
- If usage included VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, alignment must be an integer multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment.
For images created with a color format, the memoryTypeBits member is identical for all VkImage objects created with the same combination of values for the tiling member, the VK_IMAGE_CREATE_SPARSE_BINDING_BIT bit of the flags member, the VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT bit of the flags member, handleTypes member of VkExternalMemoryImageCreateInfo, and the VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT of the usage member in the VkImageCreateInfo structure passed to vkCreateImage.
For images created with a depth/stencil format, the memoryTypeBits member is identical for all VkImage objects created with the same combination of values for the format member, the tiling member, the VK_IMAGE_CREATE_SPARSE_BINDING_BIT bit of the flags member, the VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT bit of the flags member, handleTypes member of VkExternalMemoryImageCreateInfo, and the VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT of the usage member in the VkImageCreateInfo structure passed to vkCreateImage.
If the memory requirements are for a VkImage, the memoryTypeBits member must not refer to a VkMemoryType with a propertyFlags that has the VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT bit set if the image did not have VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT bit set in the usage member of the VkImageCreateInfo structure passed to vkCreateImage.
If the memory requirements are for a VkBuffer, the memoryTypeBits member must not refer to a VkMemoryType with a propertyFlags that has the VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT bit set.

Note

The implication of this requirement is that lazily allocated memory is disallowed for buffers in all cases.
The size member is identical for all VkBuffer objects created with the same combination of creation parameters specified in VkBufferCreateInfo and its pNext chain.

The size member is identical for all VkImage objects created with the same combination of creation parameters specified in VkImageCreateInfo and its pNext chain.

Note

This, however, does not imply that they interpret the contents of the bound memory identically with each other. That additional guarantee, however, can be explicitly requested using VK_IMAGE_CREATE_ALIAS_BIT.

To determine the memory requirements for a buffer resource, call:

void vkGetBufferMemoryRequirements2(
    VkDevice                                    device,
    const VkBufferMemoryRequirementsInfo2*      pInfo,
    VkMemoryRequirements2*                      pMemoryRequirements);

or the equivalent command

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

device is the logical device that owns the buffer.
pInfo is a pointer to a VkBufferMemoryRequirementsInfo2 structure containing parameters required for the memory requirements query.
pMemoryRequirements is a pointer to a VkMemoryRequirements2 structure in which the memory requirements of the buffer object are returned.

Valid Usage (Implicit)

VUID-vkGetBufferMemoryRequirements2-device-parameter
device must be a valid VkDevice handle
VUID-vkGetBufferMemoryRequirements2-pInfo-parameter
pInfo must be a valid pointer to a valid VkBufferMemoryRequirementsInfo2 structure
VUID-vkGetBufferMemoryRequirements2-pMemoryRequirements-parameter
pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2 structure

The VkBufferMemoryRequirementsInfo2 structure is defined as:

typedef struct VkBufferMemoryRequirementsInfo2 {
    VkStructureType    sType;
    const void*        pNext;
    VkBuffer           buffer;
} VkBufferMemoryRequirementsInfo2;

or the equivalent

typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
buffer is the buffer to query.

Valid Usage (Implicit)

VUID-VkBufferMemoryRequirementsInfo2-sType-sType
sType must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2
VUID-VkBufferMemoryRequirementsInfo2-pNext-pNext
pNext must be NULL
VUID-VkBufferMemoryRequirementsInfo2-buffer-parameter
buffer must be a valid VkBuffer handle

To determine the memory requirements for an image resource, call:

void vkGetImageMemoryRequirements2(
    VkDevice                                    device,
    const VkImageMemoryRequirementsInfo2*       pInfo,
    VkMemoryRequirements2*                      pMemoryRequirements);

or the equivalent command

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

device is the logical device that owns the image.
pInfo is a pointer to a VkImageMemoryRequirementsInfo2 structure containing parameters required for the memory requirements query.
pMemoryRequirements is a pointer to a VkMemoryRequirements2 structure in which the memory requirements of the image object are returned.

Valid Usage (Implicit)

VUID-vkGetImageMemoryRequirements2-device-parameter
device must be a valid VkDevice handle
VUID-vkGetImageMemoryRequirements2-pInfo-parameter
pInfo must be a valid pointer to a valid VkImageMemoryRequirementsInfo2 structure
VUID-vkGetImageMemoryRequirements2-pMemoryRequirements-parameter
pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2 structure

The VkImageMemoryRequirementsInfo2 structure is defined as:

typedef struct VkImageMemoryRequirementsInfo2 {
    VkStructureType    sType;
    const void*        pNext;
    VkImage            image;
} VkImageMemoryRequirementsInfo2;

or the equivalent

typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
image is the image to query.

Valid Usage

VUID-VkImageMemoryRequirementsInfo2-image-01589
If image was created with a multi-planar format and the VK_IMAGE_CREATE_DISJOINT_BIT flag, there must be a VkImagePlaneMemoryRequirementsInfo included in the pNext chain of the VkImageMemoryRequirementsInfo2 structure
VUID-VkImageMemoryRequirementsInfo2-image-02279
If image was created with VK_IMAGE_CREATE_DISJOINT_BIT and with VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then there must be a VkImagePlaneMemoryRequirementsInfo included in the pNext chain of the VkImageMemoryRequirementsInfo2 structure
VUID-VkImageMemoryRequirementsInfo2-image-01590
If image was not created with the VK_IMAGE_CREATE_DISJOINT_BIT flag, there must not be a VkImagePlaneMemoryRequirementsInfo included in the pNext chain of the VkImageMemoryRequirementsInfo2 structure
VUID-VkImageMemoryRequirementsInfo2-image-02280
If image was created with a single-plane format and with any tiling other than VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then there must not be a VkImagePlaneMemoryRequirementsInfo included in the pNext chain of the VkImageMemoryRequirementsInfo2 structure
VUID-VkImageMemoryRequirementsInfo2-image-01897
If image was created with the VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID external memory handle type, then image must be bound to memory.

Valid Usage (Implicit)

VUID-VkImageMemoryRequirementsInfo2-sType-sType
sType must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2
VUID-VkImageMemoryRequirementsInfo2-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkImagePlaneMemoryRequirementsInfo
VUID-VkImageMemoryRequirementsInfo2-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkImageMemoryRequirementsInfo2-image-parameter
image must be a valid VkImage handle

To determine the memory requirements for a plane of a disjoint image, add a VkImagePlaneMemoryRequirementsInfo structure to the pNext chain of the VkImageMemoryRequirementsInfo2 structure.

The VkImagePlaneMemoryRequirementsInfo structure is defined as:

typedef struct VkImagePlaneMemoryRequirementsInfo {
    VkStructureType          sType;
    const void*              pNext;
    VkImageAspectFlagBits    planeAspect;
} VkImagePlaneMemoryRequirementsInfo;

or the equivalent

typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
planeAspect is the aspect corresponding to the image plane to query.

Valid Usage

VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-02281
If the image’s tiling is VK_IMAGE_TILING_LINEAR or VK_IMAGE_TILING_OPTIMAL, then planeAspect must be a single valid format plane for the image. (That is, for a two-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT, and for a three-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT).
VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-02282
If the image’s tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then planeAspect must be a single valid memory plane for the image. (That is, aspectMask must specify a plane index that is less than the drmFormatModifierPlaneCount associated with the image’s format and drmFormatModifier.)

Valid Usage (Implicit)

VUID-VkImagePlaneMemoryRequirementsInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO
VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-parameter
planeAspect must be a valid VkImageAspectFlagBits value

The VkMemoryRequirements2 structure is defined as:

typedef struct VkMemoryRequirements2 {
    VkStructureType         sType;
    void*                   pNext;
    VkMemoryRequirements    memoryRequirements;
} VkMemoryRequirements2;

or the equivalent

typedef VkMemoryRequirements2 VkMemoryRequirements2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
memoryRequirements is a VkMemoryRequirements structure describing the memory requirements of the resource.

Valid Usage (Implicit)

VUID-VkMemoryRequirements2-sType-sType
sType must be VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2
VUID-VkMemoryRequirements2-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkMemoryDedicatedRequirements
VUID-VkMemoryRequirements2-sType-unique
The sType value of each struct in the pNext chain must be unique

To determine the dedicated allocation requirements of a buffer or image resource, add a VkMemoryDedicatedRequirements structure to the pNext chain of the VkMemoryRequirements2 structure passed as the pMemoryRequirements parameter of vkGetBufferMemoryRequirements2 or vkGetImageMemoryRequirements2.

The VkMemoryDedicatedRequirements structure is defined as:

typedef struct VkMemoryDedicatedRequirements {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           prefersDedicatedAllocation;
    VkBool32           requiresDedicatedAllocation;
} VkMemoryDedicatedRequirements;

or the equivalent

typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
prefersDedicatedAllocation specifies that the implementation would prefer a dedicated allocation for this resource. The application is still free to suballocate the resource but it may get better performance if a dedicated allocation is used.
requiresDedicatedAllocation specifies that a dedicated allocation is required for this resource.

When the implementation sets requiresDedicatedAllocation to VK_TRUE, it must also set prefersDedicatedAllocation to VK_TRUE.

If the VkMemoryDedicatedRequirements structure is included in the pNext chain of the VkMemoryRequirements2 structure passed as the pMemoryRequirements parameter of a vkGetBufferMemoryRequirements2 call, requiresDedicatedAllocation may be VK_TRUE under one of the following conditions:

The pNext chain of VkBufferCreateInfo for the call to vkCreateBuffer used to create the buffer being queried included a VkExternalMemoryBufferCreateInfo structure, and any of the handle types specified in VkExternalMemoryBufferCreateInfo::handleTypes requires dedicated allocation, as reported by vkGetPhysicalDeviceExternalBufferProperties in VkExternalBufferProperties::externalMemoryProperties.externalMemoryFeatures, the requiresDedicatedAllocation field will be set to VK_TRUE.

In all other cases, requiresDedicatedAllocation must be set to VK_FALSE by the implementation whenever a VkMemoryDedicatedRequirements structure is included in the pNext chain of the VkMemoryRequirements2 structure passed to a call to vkGetBufferMemoryRequirements2.

If the VkMemoryDedicatedRequirements structure is included in the pNext chain of the VkMemoryRequirements2 structure passed as the pMemoryRequirements parameter of a vkGetBufferMemoryRequirements2 call and VK_BUFFER_CREATE_SPARSE_BINDING_BIT was set in VkBufferCreateInfo::flags when buffer was created then the implementation must set both prefersDedicatedAllocation and requiresDedicatedAllocation to VK_FALSE.

The pNext chain of VkImageCreateInfo for the call to vkCreateImage used to create the image being queried included a VkExternalMemoryImageCreateInfo structure, and any of the handle types specified in VkExternalMemoryImageCreateInfo::handleTypes requires dedicated allocation, as reported by vkGetPhysicalDeviceImageFormatProperties2 in VkExternalImageFormatProperties::externalMemoryProperties.externalMemoryFeatures, the requiresDedicatedAllocation field will be set to VK_TRUE.

If the VkMemoryDedicatedRequirements structure is included in the pNext chain of the VkMemoryRequirements2 structure passed as the pMemoryRequirements parameter of a vkGetImageMemoryRequirements2 call and VK_IMAGE_CREATE_SPARSE_BINDING_BIT was set in VkImageCreateInfo::flags when image was created then the implementation must set both prefersDedicatedAllocation and requiresDedicatedAllocation to VK_FALSE.

Valid Usage (Implicit)

VUID-VkMemoryDedicatedRequirements-sType-sType
sType must be VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS

To attach memory to a buffer object, call:

VkResult vkBindBufferMemory(
    VkDevice                                    device,
    VkBuffer                                    buffer,
    VkDeviceMemory                              memory,
    VkDeviceSize                                memoryOffset);

device is the logical device that owns the buffer and memory.
buffer is the buffer to be attached to memory.
memory is a VkDeviceMemory object describing the device memory to attach.
memoryOffset is 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.

vkBindBufferMemory is equivalent to passing the same parameters through VkBindBufferMemoryInfo to vkBindBufferMemory2.

Valid Usage

VUID-vkBindBufferMemory-buffer-01029
buffer must not already be backed by a memory object
VUID-vkBindBufferMemory-buffer-01030
buffer must not have been created with any sparse memory binding flags
VUID-vkBindBufferMemory-memoryOffset-01031
memoryOffset must be less than the size of memory
VUID-vkBindBufferMemory-memory-01035
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 vkGetBufferMemoryRequirements with buffer
VUID-vkBindBufferMemory-memoryOffset-01036
memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer
VUID-vkBindBufferMemory-size-01037
The size member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer must be less than or equal to the size of memory minus memoryOffset
VUID-vkBindBufferMemory-buffer-01444
If buffer requires a dedicated allocation(as reported by vkGetBufferMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for buffer), memory must have been created with VkMemoryDedicatedAllocateInfo::buffer equal to buffer
VUID-vkBindBufferMemory-memory-01508
If the VkMemoryAllocateInfo provided when memory was allocated included a VkMemoryDedicatedAllocateInfo structure in its pNext chain, and VkMemoryDedicatedAllocateInfo::buffer was not VK_NULL_HANDLE, then buffer must equal VkMemoryDedicatedAllocateInfo::buffer, and memoryOffset must be zero.
VUID-vkBindBufferMemory-None-01898
If buffer was created with the VK_BUFFER_CREATE_PROTECTED_BIT bit set, the buffer must be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT
VUID-vkBindBufferMemory-None-01899
If buffer was created with the VK_BUFFER_CREATE_PROTECTED_BIT bit not set, the buffer must not be bound to a memory object created with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT
VUID-vkBindBufferMemory-buffer-01038
If buffer was created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::buffer equal to a buffer handle created with identical creation parameters to buffer and memoryOffset must be zero
VUID-vkBindBufferMemory-memory-02726
If the value of VkExportMemoryAllocateInfo::handleTypes used to allocate memory is not 0, it must include at least one of the handles set in VkExternalMemoryBufferCreateInfo::handleTypes when buffer was created
VUID-vkBindBufferMemory-memory-02727
If memory was created by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryBufferCreateInfo::handleTypes when buffer was created
VUID-vkBindBufferMemory-bufferDeviceAddress-03339
If the VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddress feature is enabled and buffer was created with the VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT bit set, memory must have been allocated with the VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT bit set

Valid Usage (Implicit)

VUID-vkBindBufferMemory-device-parameter
device must be a valid VkDevice handle
VUID-vkBindBufferMemory-buffer-parameter
buffer must be a valid VkBuffer handle
VUID-vkBindBufferMemory-memory-parameter
memory must be a valid VkDeviceMemory handle
VUID-vkBindBufferMemory-buffer-parent
buffer must have been created, allocated, or retrieved from device
VUID-vkBindBufferMemory-memory-parent
memory must have been created, allocated, or retrieved from device

Host Synchronization

Host access to buffer must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR

To attach memory to buffer objects for one or more buffers at a time, call:

VkResult vkBindBufferMemory2(
    VkDevice                                    device,
    uint32_t                                    bindInfoCount,
    const VkBindBufferMemoryInfo*               pBindInfos);

or the equivalent command

VkResult vkBindBufferMemory2KHR(
    VkDevice                                    device,
    uint32_t                                    bindInfoCount,
    const VkBindBufferMemoryInfo*               pBindInfos);

device is the logical device that owns the buffers and memory.
bindInfoCount is the number of elements in pBindInfos.
pBindInfos is a pointer to an array of bindInfoCount VkBindBufferMemoryInfo structures describing buffers and memory to bind.

On some implementations, it may be more efficient to batch memory bindings into a single command.

Valid Usage (Implicit)

VUID-vkBindBufferMemory2-device-parameter
device must be a valid VkDevice handle
VUID-vkBindBufferMemory2-pBindInfos-parameter
pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindBufferMemoryInfo structures
VUID-vkBindBufferMemory2-bindInfoCount-arraylength
bindInfoCount must be greater than 0

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR

VkBindBufferMemoryInfo contains members corresponding to the parameters of vkBindBufferMemory.

The VkBindBufferMemoryInfo structure is defined as:

typedef struct VkBindBufferMemoryInfo {
    VkStructureType    sType;
    const void*        pNext;
    VkBuffer           buffer;
    VkDeviceMemory     memory;
    VkDeviceSize       memoryOffset;
} VkBindBufferMemoryInfo;

or the equivalent

typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
buffer is the buffer to be attached to memory.
memory is a VkDeviceMemory object describing the device memory to attach.
memoryOffset is 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.

Valid Usage

VUID-VkBindBufferMemoryInfo-buffer-01593
buffer must not already be backed by a memory object
VUID-VkBindBufferMemoryInfo-buffer-01594
buffer must not have been created with any sparse memory binding flags
VUID-VkBindBufferMemoryInfo-memoryOffset-01595
memoryOffset must be less than the size of memory
VUID-VkBindBufferMemoryInfo-memory-01599
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 vkGetBufferMemoryRequirements with buffer
VUID-VkBindBufferMemoryInfo-memoryOffset-01600
memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer
VUID-VkBindBufferMemoryInfo-size-01601
The size member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer must be less than or equal to the size of memory minus memoryOffset
VUID-VkBindBufferMemoryInfo-buffer-01602
If buffer requires a dedicated allocation(as reported by vkGetBufferMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for buffer), memory must have been created with VkMemoryDedicatedAllocateInfo::buffer equal to buffer and memoryOffset must be zero
VUID-VkBindBufferMemoryInfo-memory-01900
If the VkMemoryAllocateInfo provided when memory was allocated included a VkMemoryDedicatedAllocateInfo structure in its pNext chain, and VkMemoryDedicatedAllocateInfo::buffer was not VK_NULL_HANDLE, then buffer must equal VkMemoryDedicatedAllocateInfo::buffer and memoryOffset must be zero.
VUID-VkBindBufferMemoryInfo-buffer-01603
If buffer was created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::buffer equal to buffer and memoryOffset must be zero
VUID-VkBindBufferMemoryInfo-pNext-01605
If the pNext chain includes a VkBindBufferMemoryDeviceGroupInfo structure, all instances of memory specified by VkBindBufferMemoryDeviceGroupInfo::pDeviceIndices must have been allocated
VUID-VkBindBufferMemoryInfo-handleTypes-02791
If the value of VkExportMemoryAllocateInfo::handleTypes used to allocate memory is not 0, it must include at least one of the handles set in VkExternalMemoryBufferCreateInfo::handleTypes when buffer was created
VUID-VkBindBufferMemoryInfo-memory-02792
If memory was created by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryBufferCreateInfo::handleTypes when buffer was created
VUID-VkBindBufferMemoryInfo-bufferDeviceAddress-02838
If the VkPhysicalDeviceBufferDeviceAddressFeaturesKHR::bufferDeviceAddress feature is enabled and buffer was created with the VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR bit set, memory must have been allocated with the VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR bit set

Valid Usage (Implicit)

VUID-VkBindBufferMemoryInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO
VUID-VkBindBufferMemoryInfo-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkBindBufferMemoryDeviceGroupInfo
VUID-VkBindBufferMemoryInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkBindBufferMemoryInfo-buffer-parameter
buffer must be a valid VkBuffer handle
VUID-VkBindBufferMemoryInfo-memory-parameter
memory must be a valid VkDeviceMemory handle
VUID-VkBindBufferMemoryInfo-commonparent
Both of buffer, and memory must have been created, allocated, or retrieved from the same VkDevice

typedef struct VkBindBufferMemoryDeviceGroupInfo {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           deviceIndexCount;
    const uint32_t*    pDeviceIndices;
} VkBindBufferMemoryDeviceGroupInfo;

or the equivalent

typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR;

If the pNext list of VkBindBufferMemoryInfo includes a VkBindBufferMemoryDeviceGroupInfo structure, then that structure determines how memory is bound to buffers across multiple devices in a device group.

The VkBindBufferMemoryDeviceGroupInfo structure is defined as:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
deviceIndexCount is the number of elements in pDeviceIndices.
pDeviceIndices is a pointer to an array of device indices.

If deviceIndexCount is greater than zero, then on device index i the buffer is attached to the instance of memory on the physical device with device index pDeviceIndices[i].

If deviceIndexCount is zero and memory comes from a memory heap with the VK_MEMORY_HEAP_MULTI_INSTANCE_BIT bit set, then it is as if pDeviceIndices contains consecutive indices from zero to the number of physical devices in the logical device, minus one. In other words, by default each physical device attaches to its own instance of memory.

If deviceIndexCount is zero and memory comes from a memory heap without the VK_MEMORY_HEAP_MULTI_INSTANCE_BIT bit set, then it is as if pDeviceIndices contains an array of zeros. In other words, by default each physical device attaches to instance zero.

Valid Usage

VUID-VkBindBufferMemoryDeviceGroupInfo-deviceIndexCount-01606
deviceIndexCount must either be zero or equal to the number of physical devices in the logical device
VUID-VkBindBufferMemoryDeviceGroupInfo-pDeviceIndices-01607
All elements of pDeviceIndices must be valid device indices

Valid Usage (Implicit)

VUID-VkBindBufferMemoryDeviceGroupInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO
VUID-VkBindBufferMemoryDeviceGroupInfo-pDeviceIndices-parameter
If deviceIndexCount is not 0, pDeviceIndices must be a valid pointer to an array of deviceIndexCount uint32_t values

To attach memory to a VkImage object created without the VK_IMAGE_CREATE_DISJOINT_BIT set, call:

VkResult vkBindImageMemory(
    VkDevice                                    device,
    VkImage                                     image,
    VkDeviceMemory                              memory,
    VkDeviceSize                                memoryOffset);

device is the logical device that owns the image and memory.
image is the image.
memory is the VkDeviceMemory object describing the device memory to attach.
memoryOffset is 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.

vkBindImageMemory is equivalent to passing the same parameters through VkBindImageMemoryInfo to vkBindImageMemory2.

Valid Usage

VUID-vkBindImageMemory-image-01608
image must not have been created with the VK_IMAGE_CREATE_DISJOINT_BIT set.
VUID-vkBindImageMemory-image-01044
image must not already be backed by a memory object
VUID-vkBindImageMemory-image-01045
image must not have been created with any sparse memory binding flags
VUID-vkBindImageMemory-memoryOffset-01046
memoryOffset must be less than the size of memory
VUID-vkBindImageMemory-memory-01047
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 vkGetImageMemoryRequirements with image
VUID-vkBindImageMemory-memoryOffset-01048
memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image
VUID-vkBindImageMemory-size-01049
The difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with the same image
VUID-vkBindImageMemory-image-01445
If image requires a dedicated allocation (as reported by vkGetImageMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for image), memory must have been created with VkMemoryDedicatedAllocateInfo::image equal to image
VUID-vkBindImageMemory-memory-02628
If the dedicated allocation image aliasing feature is not enabled, and the VkMemoryAllocateInfo provided when memory was allocated included a VkMemoryDedicatedAllocateInfo structure in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero.
VUID-vkBindImageMemory-memory-02629
If the dedicated allocation image aliasing feature is enabled, and the VkMemoryAllocateInfo provided when memory was allocated included a VkMemoryDedicatedAllocateInfo structure in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then memoryOffset must be zero, and image must be either equal to VkMemoryDedicatedAllocateInfo::image or an image that was created using the same parameters in VkImageCreateInfo, with the exception that extent and arrayLayers may differ subject to the following restrictions: every dimension in the extent parameter of the image being bound must be equal to or smaller than the original image for which the allocation was created; and the arrayLayers parameter of the image being bound must be equal to or smaller than the original image for which the allocation was created.
VUID-vkBindImageMemory-None-01901
If image was created with the VK_IMAGE_CREATE_PROTECTED_BIT bit set, the image must be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT
VUID-vkBindImageMemory-None-01902
If image was created with the VK_IMAGE_CREATE_PROTECTED_BIT bit not set, the image must not be bound to a memory object created with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT
VUID-vkBindImageMemory-image-01050
If image was created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::image equal to an image handle created with identical creation parameters to image and memoryOffset must be zero
VUID-vkBindImageMemory-memory-02728
If the value of VkExportMemoryAllocateInfo::handleTypes used to allocate memory is not 0, it must include at least one of the handles set in VkExternalMemoryImageCreateInfo::handleTypes when image was created
VUID-vkBindImageMemory-memory-02729
If memory was created by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when image was created

Valid Usage (Implicit)

VUID-vkBindImageMemory-device-parameter
device must be a valid VkDevice handle
VUID-vkBindImageMemory-image-parameter
image must be a valid VkImage handle
VUID-vkBindImageMemory-memory-parameter
memory must be a valid VkDeviceMemory handle
VUID-vkBindImageMemory-image-parent
image must have been created, allocated, or retrieved from device
VUID-vkBindImageMemory-memory-parent
memory must have been created, allocated, or retrieved from device

Host Synchronization

Host access to image must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

To attach memory to image objects for one or more images at a time, call:

VkResult vkBindImageMemory2(
    VkDevice                                    device,
    uint32_t                                    bindInfoCount,
    const VkBindImageMemoryInfo*                pBindInfos);

or the equivalent command

VkResult vkBindImageMemory2KHR(
    VkDevice                                    device,
    uint32_t                                    bindInfoCount,
    const VkBindImageMemoryInfo*                pBindInfos);

device is the logical device that owns the images and memory.
bindInfoCount is the number of elements in pBindInfos.
pBindInfos is a pointer to an array of VkBindImageMemoryInfo structures, describing images and memory to bind.

On some implementations, it may be more efficient to batch memory bindings into a single command.

Valid Usage

VUID-vkBindImageMemory2-pBindInfos-02858
If any VkBindImageMemoryInfo::image was created with VK_IMAGE_CREATE_DISJOINT_BIT then all planes of VkBindImageMemoryInfo::image must be bound individually in separate pBindInfos

Valid Usage (Implicit)

VUID-vkBindImageMemory2-device-parameter
device must be a valid VkDevice handle
VUID-vkBindImageMemory2-pBindInfos-parameter
pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindImageMemoryInfo structures
VUID-vkBindImageMemory2-bindInfoCount-arraylength
bindInfoCount must be greater than 0

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

VkBindImageMemoryInfo contains members corresponding to the parameters of vkBindImageMemory.

The VkBindImageMemoryInfo structure is defined as:

typedef struct VkBindImageMemoryInfo {
    VkStructureType    sType;
    const void*        pNext;
    VkImage            image;
    VkDeviceMemory     memory;
    VkDeviceSize       memoryOffset;
} VkBindImageMemoryInfo;

or the equivalent

typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
image is the image to be attached to memory.
memory is a VkDeviceMemory object describing the device memory to attach.
memoryOffset is 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.

Valid Usage

VUID-VkBindImageMemoryInfo-image-01609
image must not already be backed by a memory object
VUID-VkBindImageMemoryInfo-image-01610
image must not have been created with any sparse memory binding flags
VUID-VkBindImageMemoryInfo-memoryOffset-01611
memoryOffset must be less than the size of memory
VUID-VkBindImageMemoryInfo-pNext-01615
If the pNext chain does not include a VkBindImagePlaneMemoryInfo structure, 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 vkGetImageMemoryRequirements2 with image
VUID-VkBindImageMemoryInfo-pNext-01616
If the pNext chain does not include a VkBindImagePlaneMemoryInfo structure, memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image
VUID-VkBindImageMemoryInfo-pNext-01617
If the pNext chain does not include a VkBindImagePlaneMemoryInfo structure, the difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with the same image
VUID-VkBindImageMemoryInfo-pNext-01618
If the pNext chain includes a VkBindImagePlaneMemoryInfo structure, image must have been created with the VK_IMAGE_CREATE_DISJOINT_BIT bit set.
VUID-VkBindImageMemoryInfo-pNext-01619
If the pNext chain includes a VkBindImagePlaneMemoryInfo structure, 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 vkGetImageMemoryRequirements2 with image and where VkBindImagePlaneMemoryInfo::planeAspect corresponds to the VkImagePlaneMemoryRequirementsInfo::planeAspect in the VkImageMemoryRequirementsInfo2 structure’s pNext chain
VUID-VkBindImageMemoryInfo-pNext-01620
If the pNext chain includes a VkBindImagePlaneMemoryInfo structure, memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image and where VkBindImagePlaneMemoryInfo::planeAspect corresponds to the VkImagePlaneMemoryRequirementsInfo::planeAspect in the VkImageMemoryRequirementsInfo2 structure’s pNext chain
VUID-VkBindImageMemoryInfo-pNext-01621
If the pNext chain includes a VkBindImagePlaneMemoryInfo structure, the difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with the same image and where VkBindImagePlaneMemoryInfo::planeAspect corresponds to the VkImagePlaneMemoryRequirementsInfo::planeAspect in the VkImageMemoryRequirementsInfo2 structure’s pNext chain
VUID-VkBindImageMemoryInfo-image-01622
If image requires a dedicated allocation (as reported by vkGetImageMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for image), memory must have been created with VkMemoryDedicatedAllocateInfo::image equal to image and memoryOffset must be zero
VUID-VkBindImageMemoryInfo-memory-02630
If the dedicated allocation image aliasing feature is not enabled, and the VkMemoryAllocateInfo provided when memory was allocated included a VkMemoryDedicatedAllocateInfo structure in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero.
VUID-VkBindImageMemoryInfo-memory-02631
If the dedicated allocation image aliasing feature is enabled, and the VkMemoryAllocateInfo provided when memory was allocated included a VkMemoryDedicatedAllocateInfo structure in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then memoryOffset must be zero, and image must be either equal to VkMemoryDedicatedAllocateInfo::image or an image that was created using the same parameters in VkImageCreateInfo, with the exception that extent and arrayLayers may differ subject to the following restrictions: every dimension in the extent parameter of the image being bound must be equal to or smaller than the original image for which the allocation was created; and the arrayLayers parameter of the image being bound must be equal to or smaller than the original image for which the allocation was created.
VUID-VkBindImageMemoryInfo-image-01623
If image was created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::image equal to image and memoryOffset must be zero
VUID-VkBindImageMemoryInfo-pNext-01626
If the pNext chain includes a VkBindImageMemoryDeviceGroupInfo structure, all instances of memory specified by VkBindImageMemoryDeviceGroupInfo::pDeviceIndices must have been allocated
VUID-VkBindImageMemoryInfo-pNext-01627
If the pNext chain includes a VkBindImageMemoryDeviceGroupInfo structure, and VkBindImageMemoryDeviceGroupInfo::splitInstanceBindRegionCount is not zero, then image must have been created with the VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT bit set
VUID-VkBindImageMemoryInfo-pNext-01628
If the pNext chain includes a VkBindImageMemoryDeviceGroupInfo structure, all elements of VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions must be valid rectangles contained within the dimensions of image
VUID-VkBindImageMemoryInfo-pNext-01629
If the pNext chain includes a VkBindImageMemoryDeviceGroupInfo structure, the union of the areas of all elements of VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions that correspond to the same instance of image must cover the entire image.
VUID-VkBindImageMemoryInfo-image-01630
If image was created with a valid swapchain handle in VkImageSwapchainCreateInfoKHR::swapchain, then the pNext chain must include a VkBindImageMemorySwapchainInfoKHR structure containing the same swapchain handle.
VUID-VkBindImageMemoryInfo-pNext-01631
If the pNext chain includes a VkBindImageMemorySwapchainInfoKHR structure, memory must be VK_NULL_HANDLE
VUID-VkBindImageMemoryInfo-pNext-01632
If the pNext chain does not include a VkBindImageMemorySwapchainInfoKHR structure, memory must be a valid VkDeviceMemory handle
VUID-VkBindImageMemoryInfo-handleTypes-02793
If the value of VkExportMemoryAllocateInfo::handleTypes used to allocate memory is not 0, it must include at least one of the handles set in VkExternalMemoryImageCreateInfo::handleTypes when image was created
VUID-VkBindImageMemoryInfo-memory-02794
If memory was created by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when image was created

Valid Usage (Implicit)

VUID-VkBindImageMemoryInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO
VUID-VkBindImageMemoryInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkBindImageMemoryDeviceGroupInfo, VkBindImageMemorySwapchainInfoKHR, or VkBindImagePlaneMemoryInfo
VUID-VkBindImageMemoryInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkBindImageMemoryInfo-image-parameter
image must be a valid VkImage handle
VUID-VkBindImageMemoryInfo-commonparent
Both of image, and memory that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

typedef struct VkBindImageMemoryDeviceGroupInfo {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           deviceIndexCount;
    const uint32_t*    pDeviceIndices;
    uint32_t           splitInstanceBindRegionCount;
    const VkRect2D*    pSplitInstanceBindRegions;
} VkBindImageMemoryDeviceGroupInfo;

or the equivalent

typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR;

If the pNext list of VkBindImageMemoryInfo includes a VkBindImageMemoryDeviceGroupInfo structure, then that structure determines how memory is bound to images across multiple devices in a device group.

The VkBindImageMemoryDeviceGroupInfo structure is defined as:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
deviceIndexCount is the number of elements in pDeviceIndices.
pDeviceIndices is a pointer to an array of device indices.
splitInstanceBindRegionCount is the number of elements in pSplitInstanceBindRegions.
pSplitInstanceBindRegions is a pointer to an array of VkRect2D structures describing which regions of the image are attached to each instance of memory.

If deviceIndexCount is greater than zero, then on device index i image is attached to the instance of the memory on the physical device with device index pDeviceIndices[i].

Let N be the number of physical devices in the logical device. If splitInstanceBindRegionCount is greater than zero, then pSplitInstanceBindRegions is an array of N² rectangles, where the image region specified by the rectangle at element i*N+j in resource instance i is bound to the memory instance j. The blocks of the memory that are bound to each sparse image block region use an offset in memory, relative to memoryOffset, computed as if the whole image were being bound to a contiguous range of memory. In other words, horizontally adjacent image blocks use consecutive blocks of memory, vertically adjacent image blocks are separated by the number of bytes per block multiplied by the width in blocks of image, and the block at (0,0) corresponds to memory starting at memoryOffset.

If splitInstanceBindRegionCount and deviceIndexCount are zero and the memory comes from a memory heap with the VK_MEMORY_HEAP_MULTI_INSTANCE_BIT bit set, then it is as if pDeviceIndices contains consecutive indices from zero to the number of physical devices in the logical device, minus one. In other words, by default each physical device attaches to its own instance of the memory.

If splitInstanceBindRegionCount and deviceIndexCount are zero and the memory comes from a memory heap without the VK_MEMORY_HEAP_MULTI_INSTANCE_BIT bit set, then it is as if pDeviceIndices contains an array of zeros. In other words, by default each physical device attaches to instance zero.

Valid Usage

VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01633
At least one of deviceIndexCount and splitInstanceBindRegionCount must be zero.
VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01634
deviceIndexCount must either be zero or equal to the number of physical devices in the logical device
VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-01635
All elements of pDeviceIndices must be valid device indices.
VUID-VkBindImageMemoryDeviceGroupInfo-splitInstanceBindRegionCount-01636
splitInstanceBindRegionCount must either be zero or equal to the number of physical devices in the logical device squared
VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-01637
Elements of pSplitInstanceBindRegions that correspond to the same instance of an image must not overlap.
VUID-VkBindImageMemoryDeviceGroupInfo-offset-01638
The offset.x member of any element of pSplitInstanceBindRegions must be a multiple of the sparse image block width (VkSparseImageFormatProperties::imageGranularity.width) of all non-metadata aspects of the image
VUID-VkBindImageMemoryDeviceGroupInfo-offset-01639
The offset.y member of any element of pSplitInstanceBindRegions must be a multiple of the sparse image block height (VkSparseImageFormatProperties::imageGranularity.height) of all non-metadata aspects of the image
VUID-VkBindImageMemoryDeviceGroupInfo-extent-01640
The extent.width member of any element of pSplitInstanceBindRegions must either be a multiple of the sparse image block width of all non-metadata aspects of the image, or else extent.width + offset.x must equal the width of the image subresource
VUID-VkBindImageMemoryDeviceGroupInfo-extent-01641
The extent.height member of any element of pSplitInstanceBindRegions must either be a multiple of the sparse image block height of all non-metadata aspects of the image, or else extent.height + offset.y must equal the width of the image subresource

Valid Usage (Implicit)

VUID-VkBindImageMemoryDeviceGroupInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO
VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-parameter
If deviceIndexCount is not 0, pDeviceIndices must be a valid pointer to an array of deviceIndexCount uint32_t values
VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-parameter
If splitInstanceBindRegionCount is not 0, pSplitInstanceBindRegions must be a valid pointer to an array of splitInstanceBindRegionCount VkRect2D structures

If the pNext chain of VkBindImageMemoryInfo includes a VkBindImageMemorySwapchainInfoKHR structure, then that structure includes a swapchain handle and image index indicating that the image will be bound to memory from that swapchain.

The VkBindImageMemorySwapchainInfoKHR structure is defined as:

typedef struct VkBindImageMemorySwapchainInfoKHR {
    VkStructureType    sType;
    const void*        pNext;
    VkSwapchainKHR     swapchain;
    uint32_t           imageIndex;
} VkBindImageMemorySwapchainInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
swapchain is VK_NULL_HANDLE or a swapchain handle.
imageIndex is an image index within swapchain.

If swapchain is not NULL, the swapchain and imageIndex are used to determine the memory that the image is bound to, instead of memory and memoryOffset.

Memory can be bound to a swapchain and use the pDeviceIndices or pSplitInstanceBindRegions members of VkBindImageMemoryDeviceGroupInfo.

Valid Usage

VUID-VkBindImageMemorySwapchainInfoKHR-imageIndex-01644
imageIndex must be less than the number of images in swapchain

Valid Usage (Implicit)

VUID-VkBindImageMemorySwapchainInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR
VUID-VkBindImageMemorySwapchainInfoKHR-swapchain-parameter
swapchain must be a valid VkSwapchainKHR handle

Host Synchronization

Host access to swapchain must be externally synchronized

In order to bind planes of a disjoint image, add a VkBindImagePlaneMemoryInfo structure to the pNext chain of VkBindImageMemoryInfo.

The VkBindImagePlaneMemoryInfo structure is defined as:

typedef struct VkBindImagePlaneMemoryInfo {
    VkStructureType          sType;
    const void*              pNext;
    VkImageAspectFlagBits    planeAspect;
} VkBindImagePlaneMemoryInfo;

or the equivalent

typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
planeAspect is the aspect of the disjoint image plane to bind.

Valid Usage

VUID-VkBindImagePlaneMemoryInfo-planeAspect-02283
If the image’s tiling is VK_IMAGE_TILING_LINEAR or VK_IMAGE_TILING_OPTIMAL, then planeAspect must be a single valid format plane for the image. (That is, planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT for “_2PLANE” formats and planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT for “_3PLANE” formats.)
VUID-VkBindImagePlaneMemoryInfo-planeAspect-02284
If the image’s tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then planeAspect must be a single valid memory plane for the image. (That is, aspectMask must specify a plane index that is less than the drmFormatModifierPlaneCount associated with the image’s format and drmFormatModifier.)

Valid Usage (Implicit)

VUID-VkBindImagePlaneMemoryInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO
VUID-VkBindImagePlaneMemoryInfo-planeAspect-parameter
planeAspect must be a valid VkImageAspectFlagBits value

Buffer-Image Granularity

There is an implementation-dependent limit, bufferImageGranularity, which specifies a page-like granularity at which linear and non-linear resources must be placed in adjacent memory locations to avoid aliasing. Two resources which do not satisfy this granularity requirement are said to alias. bufferImageGranularity is specified in bytes, and must be a power of two. Implementations which do not impose a granularity restriction may report a bufferImageGranularity value of one.

Note

Despite its name, bufferImageGranularity is really a granularity between “linear” and “non-linear” resources.

Given resourceA at the lower memory offset and resourceB at the higher memory offset in the same VkDeviceMemory object, where one resource is linear and the other is non-linear (as defined in the Glossary), and the following:

resourceA.end       = resourceA.memoryOffset + resourceA.size - 1
resourceA.endPage   = resourceA.end & ~(bufferImageGranularity-1)
resourceB.start     = resourceB.memoryOffset
resourceB.startPage = resourceB.start & ~(bufferImageGranularity-1)

The following property must hold:

resourceA.endPage < resourceB.startPage

That is, the end of the first resource (A) and the beginning of the second resource (B) must be on separate “pages” of size bufferImageGranularity. bufferImageGranularity may be different than the physical page size of the memory heap. This restriction is only needed when a linear resource and a non-linear resource are adjacent in memory and will be used simultaneously. The memory ranges of adjacent resources can be closer than bufferImageGranularity, provided they meet the alignment requirement for the objects in question.

Sparse block size in bytes and sparse image and buffer memory alignments must all be multiples of the bufferImageGranularity. Therefore, memory bound to sparse resources naturally satisfies the bufferImageGranularity.

Buffer and image objects are created with a sharing mode controlling how they can be accessed from queues. The supported sharing modes are:

typedef enum VkSharingMode {
    VK_SHARING_MODE_EXCLUSIVE = 0,
    VK_SHARING_MODE_CONCURRENT = 1,
    VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
} VkSharingMode;

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.
VK_SHARING_MODE_CONCURRENT specifies that concurrent access to any range or image subresource of the object from multiple queue families is supported.

Note

VK_SHARING_MODE_CONCURRENT may result in lower performance access to the buffer or image than VK_SHARING_MODE_EXCLUSIVE.

Ranges of buffers and image subresources of image objects created using VK_SHARING_MODE_EXCLUSIVE must only be accessed by queues in the queue family that has ownership of the resource. Upon creation, such resources are not owned by any queue family; ownership is implicitly acquired upon first use within a queue. Once a resource using VK_SHARING_MODE_EXCLUSIVE is owned by some queue family, the application must perform a queue family ownership transfer to make the memory contents of a range or image subresource accessible to a different queue family.

Note

Images still require a layout transition from VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED before being used on the first queue.

A queue family can take ownership of an image subresource or buffer range of a resource created with VK_SHARING_MODE_EXCLUSIVE, without an ownership transfer, in the same way as for a resource that was just created; however, taking ownership in this way has the effect that the contents of the image subresource or buffer range are undefined.

Ranges of buffers and image subresources of image objects created using VK_SHARING_MODE_CONCURRENT must only be accessed by queues from the queue families specified through the queueFamilyIndexCount and pQueueFamilyIndices members of the corresponding create info structures.

Resources should only be accessed in the Vulkan instance that has exclusive ownership of their underlying memory. Only one Vulkan instance has exclusive ownership of a resource’s underlying memory at a given time, regardless of whether the resource was created using VK_SHARING_MODE_EXCLUSIVE or VK_SHARING_MODE_CONCURRENT. Applications can transfer ownership of a resource’s underlying memory only if the memory has been imported from or exported to another instance or external API using external memory handles. The semantics for transferring ownership outside of the instance are similar to those used for transferring ownership of VK_SHARING_MODE_EXCLUSIVE resources between queues, and is also accomplished using VkBufferMemoryBarrier or VkImageMemoryBarrier operations. Applications must

Release exclusive ownership from the source instance or API.
Ensure the release operation has completed using semaphores or fences.
Acquire exclusive ownership in the destination instance or API

Unlike queue ownership transfers, the destination instance or API is not specified explicitly when releasing ownership, nor is the source instance or API specified when acquiring ownership. Instead, the image or memory barrier’s dstQueueFamilyIndex or srcQueueFamilyIndex parameters are set to the reserved queue family index VK_QUEUE_FAMILY_EXTERNAL or VK_QUEUE_FAMILY_FOREIGN_EXT to represent the external destination or source respectively.

Binding a resource to a memory object shared between multiple Vulkan instances or other APIs does not change the ownership of the underlying memory. The first entity to access the resource implicitly acquires ownership. Accessing a resource backed by memory that is owned by a particular instance or API has the same semantics as accessing a VK_SHARING_MODE_EXCLUSIVE resource, with one exception: Implementations must ensure layout transitions performed on one member of a set of identical subresources of identical images that alias the same range of an underlying memory object affect the layout of all the subresources in the set.

As a corollary, writes to any image subresources in such a set must not make the contents of memory used by other subresources in the set undefined. An application can define the content of a subresource of one image by performing device writes to an identical subresource of another image provided both images are bound to the same region of external memory. Applications may also add resources to such a set after the content of the existing set members has been defined without making the content undefined by creating a new image with the initial layout VK_IMAGE_LAYOUT_UNDEFINED and binding it to the same region of external memory as the existing images.

Note

Because layout transitions apply to all identical images aliasing the same region of external memory, the actual layout of the memory backing a new image as well as an existing image with defined content will not be undefined. Such an image is not usable until it acquires ownership of its memory from the existing owner. Therefore, the layout specified as part of this transition will be the true initial layout of the image. The undefined layout specified when creating it is a placeholder to simplify valid usage requirements.

11.8. Memory Aliasing

A range of a VkDeviceMemory allocation is aliased if it is bound to multiple resources simultaneously, as described below, via vkBindImageMemory, vkBindBufferMemory, via sparse memory bindings, or by binding the memory to resources in multiple Vulkan instances or external APIs using external memory handle export and import mechanisms.

Consider two resources, resource_A and resource_B, bound respectively to memory range_A and range_B. Let paddedRange_A and paddedRange_B be, respectively, range_A and range_B aligned to bufferImageGranularity. If the resources are both linear or both non-linear (as defined in the Glossary), then the resources alias the memory in the intersection of range_A and range_B. If one resource is linear and the other is non-linear, then the resources alias the memory in the intersection of paddedRange_A and paddedRange_B.

Applications can alias memory, but use of multiple aliases is subject to several constraints.

Note

Memory aliasing can be useful to reduce the total device memory footprint of an application, if some large resources are used for disjoint periods of time.

When a non-linear, non-VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT image is bound to an aliased range, all image subresources of the image overlap the range. When a linear image is bound to an aliased range, the image subresources that (according to the image’s advertised layout) include bytes from the aliased range overlap the range. When a VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT image has sparse image blocks bound to an aliased range, only image subresources including those sparse image blocks overlap the range, and when the memory bound to the image’s mip tail overlaps an aliased range all image subresources in the mip tail overlap the range.

Buffers, and linear image subresources in either the VK_IMAGE_LAYOUT_PREINITIALIZED or VK_IMAGE_LAYOUT_GENERAL layouts, are host-accessible subresources. That is, the host has a well-defined addressing scheme to interpret the contents, and thus the layout of the data in memory can be consistently interpreted across aliases if each of those aliases is a host-accessible subresource. Non-linear images, and linear image subresources in other layouts, are not host-accessible.

If two aliases are both host-accessible, then they interpret the contents of the memory in consistent ways, and data written to one alias can be read by the other alias.

If two aliases are both images that were created with identical creation parameters, both were created with the VK_IMAGE_CREATE_ALIAS_BIT flag set, and both are bound identically to memory except for VkBindImageMemoryDeviceGroupInfo::pDeviceIndices and VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions, then they interpret the contents of the memory in consistent ways, and data written to one alias can be read by the other alias.

Additionally, if an invididual plane of a multi-planar image and a single-plane image alias the same memory, then they also interpret the contents of the memory in consistent ways under the same conditions, but with the following modifications:

Both must have been created with the VK_IMAGE_CREATE_DISJOINT_BIT flag.
The single-plane image must have a VkFormat that is equivalent to that of the multi-planar image’s individual plane.
The single-plane image and the individual plane of the multi-planar image must be bound identically to memory except for VkBindImageMemoryDeviceGroupInfo::pDeviceIndices and VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions.
The width and height of the single-plane image are derived from the multi-planar image’s dimensions in the manner listed for plane compatibility for the aliased plane.
If either image’s tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then both images must be linear.
All other creation parameters must be identical

Aliases created by binding the same memory to resources in multiple Vulkan instances or external APIs using external memory handle export and import mechanisms interpret the contents of the memory in consistent ways, and data written to one alias can be read by the other alias.

Otherwise, the aliases interpret the contents of the memory differently, and writes via one alias make the contents of memory partially or completely undefined to the other alias. If the first alias is a host-accessible subresource, then the bytes affected are those written by the memory operations according to its addressing scheme. If the first alias is not host-accessible, then the bytes affected are those overlapped by the image subresources that were written. If the second alias is a host-accessible subresource, the affected bytes become undefined. If the second alias is a not host-accessible, all sparse image blocks (for sparse partially-resident images) or all image subresources (for non-sparse image and fully resident sparse images) that overlap the affected bytes become undefined.

If any image subresources are made undefined due to writes to an alias, then each of those image subresources must have its layout transitioned from VK_IMAGE_LAYOUT_UNDEFINED to a valid layout before it is used, or from VK_IMAGE_LAYOUT_PREINITIALIZED if the memory has been written by the host. If any sparse blocks of a sparse image have been made undefined, then only the image subresources containing them must be transitioned.

Use of an overlapping range by two aliases must be separated by a memory dependency using the appropriate access types if at least one of those uses performs writes, whether the aliases interpret memory consistently or not. If buffer or image memory barriers are used, the scope of the barrier must contain the entire range and/or set of image subresources that overlap.

If two aliasing image views are used in the same framebuffer, then the render pass must declare the attachments using the VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT, and follow the other rules listed in that section.

Note

Memory recycled via an application suballocator (i.e. without freeing and reallocating the memory objects) is not substantially different from memory aliasing. However, a suballocator usually waits on a fence before recycling a region of memory, and signaling a fence involves sufficient implicit dependencies to satisfy all the above requirements.

11.9. Acceleration Structures

Acceleration structures are an opaque structure that is built by the implementation to more efficiently perform spatial queries on the provided geometric data. For this extension, an acceleration structure is either a top-level acceleration structure containing a set of bottom-level acceleration structures or a bottom-level acceleration structure containing either a set of axis-aligned bounding boxes for custom geometry or a set of triangles.

Each instance in the top-level acceleration structure contains a reference to a bottom-level acceleration structure as well as an instance transform plus information required to index into the shader bindings. The top-level acceleration structure is what is bound to the acceleration descriptor to trace inside the shader in the ray tracing pipeline.

Acceleration structures are represented by VkAccelerationStructureNV handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV)

To create acceleration structures, call:

VkResult vkCreateAccelerationStructureNV(
    VkDevice                                    device,
    const VkAccelerationStructureCreateInfoNV*  pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkAccelerationStructureNV*                  pAccelerationStructure);

device is the logical device that creates the buffer object.
pCreateInfo is a pointer to a VkAccelerationStructureCreateInfoNV structure containing parameters affecting creation of the acceleration structure.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pAccelerationStructure is a pointer to a VkAccelerationStructureNV handle in which the resulting acceleration structure object is returned.

Similar to other objects in Vulkan, the acceleration structure creation merely creates an object with a specific “shape” as specified by the information in VkAccelerationStructureInfoNV and compactedSize in pCreateInfo. Populating the data in the object after allocating and binding memory is done with vkCmdBuildAccelerationStructureNV and vkCmdCopyAccelerationStructureNV.

Acceleration structure creation uses the count and type information from the geometries, but does not use the data references in the structures.

Valid Usage (Implicit)

VUID-vkCreateAccelerationStructureNV-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateAccelerationStructureNV-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkAccelerationStructureCreateInfoNV structure
VUID-vkCreateAccelerationStructureNV-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateAccelerationStructureNV-pAccelerationStructure-parameter
pAccelerationStructure must be a valid pointer to a VkAccelerationStructureNV handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY

The VkAccelerationStructureCreateInfoNV structure is defined as:

typedef struct VkAccelerationStructureCreateInfoNV {
    VkStructureType                  sType;
    const void*                      pNext;
    VkDeviceSize                     compactedSize;
    VkAccelerationStructureInfoNV    info;
} VkAccelerationStructureCreateInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
compactedSize is the size from the result of vkCmdWriteAccelerationStructuresPropertiesNV if this acceleration structure is going to be the target of a compacting copy.
info is the VkAccelerationStructureInfoNV structure specifying further parameters of the created acceleration structure.

Valid Usage

VUID-VkAccelerationStructureCreateInfoNV-compactedSize-02421
If compactedSize is not 0 then both info.geometryCount and info.instanceCount must be 0

Valid Usage (Implicit)

VUID-VkAccelerationStructureCreateInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV
VUID-VkAccelerationStructureCreateInfoNV-pNext-pNext
pNext must be NULL
VUID-VkAccelerationStructureCreateInfoNV-info-parameter
info must be a valid VkAccelerationStructureInfoNV structure

The VkAccelerationStructureInfoNV structure is defined as:

typedef struct VkAccelerationStructureInfoNV {
    VkStructureType                        sType;
    const void*                            pNext;
    VkAccelerationStructureTypeNV          type;
    VkBuildAccelerationStructureFlagsNV    flags;
    uint32_t                               instanceCount;
    uint32_t                               geometryCount;
    const VkGeometryNV*                    pGeometries;
} VkAccelerationStructureInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
type is a VkAccelerationStructureTypeNV value specifying the type of acceleration structure that will be created.
flags is a bitmask of VkBuildAccelerationStructureFlagBitsNV specifying additional parameters of the acceleration structure.
instanceCount specifies the number of instances that will be in the new acceleration structure.
geometryCount specifies the number of geometries that will be in the new acceleration structure.
pGeometries is a pointer to an array of geometryCount VkGeometryNV structures containing the scene data being passed into the acceleration structure.

VkAccelerationStructureInfoNV contains information that is used both for acceleration structure creation with vkCreateAccelerationStructureNV and in combination with the actual geometric data to build the acceleration structure with vkCmdBuildAccelerationStructureNV.

Valid Usage

VUID-VkAccelerationStructureInfoNV-geometryCount-02422
geometryCount must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxGeometryCount
VUID-VkAccelerationStructureInfoNV-instanceCount-02423
instanceCount must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxInstanceCount
VUID-VkAccelerationStructureInfoNV-maxTriangleCount-02424
The total number of triangles in all geometries must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxTriangleCount
VUID-VkAccelerationStructureInfoNV-type-02425
If type is VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV then geometryCount must be 0
VUID-VkAccelerationStructureInfoNV-type-02426
If type is VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV then instanceCount must be 0
VUID-VkAccelerationStructureInfoNV-type-02786
If type is VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV then the geometryType member of each geometry in pGeometries must be the same
VUID-VkAccelerationStructureInfoNV-flags-02592
If flags has the VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV bit set, then it must not have the VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV bit set
VUID-VkAccelerationStructureInfoNV-scratch-02781
scratch must have been created with VK_BUFFER_USAGE_RAY_TRACING_BIT_NV usage flag
VUID-VkAccelerationStructureInfoNV-instanceData-02782
If instanceData is not VK_NULL_HANDLE, instanceData must have been created with VK_BUFFER_USAGE_RAY_TRACING_BIT_NV usage flag

Valid Usage (Implicit)

VUID-VkAccelerationStructureInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV
VUID-VkAccelerationStructureInfoNV-pNext-pNext
pNext must be NULL
VUID-VkAccelerationStructureInfoNV-type-parameter
type must be a valid VkAccelerationStructureTypeNV value
VUID-VkAccelerationStructureInfoNV-flags-parameter
flags must be a valid combination of VkBuildAccelerationStructureFlagBitsNV values
VUID-VkAccelerationStructureInfoNV-pGeometries-parameter
If geometryCount is not 0, pGeometries must be a valid pointer to an array of geometryCount valid VkGeometryNV structures

Values which can be set in VkAccelerationStructureInfoNV::type, specifying the type of acceleration structure, are:

typedef enum VkAccelerationStructureTypeNV {
    VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = 0,
    VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = 1,
    VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
} VkAccelerationStructureTypeNV;

VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV is a top-level acceleration structure containing instance data referring to bottom-level level acceleration structures.
VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV is a bottom-level acceleration structure containing the AABBs or geometry to be intersected.

Bits which can be set in VkAccelerationStructureInfoNV::flags, specifying additional parameters for acceleration structure builds, are:

typedef enum VkBuildAccelerationStructureFlagBitsNV {
    VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = 0x00000001,
    VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = 0x00000002,
    VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = 0x00000004,
    VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = 0x00000008,
    VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = 0x00000010,
    VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
} VkBuildAccelerationStructureFlagBitsNV;

VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV indicates that the specified acceleration structure can be updated with update of VK_TRUE in vkCmdBuildAccelerationStructureNV.
VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV indicates that the specified acceleration structure can act as the source for vkCmdCopyAccelerationStructureNV with mode of VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV to produce a compacted acceleration structure.
VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV indicates that the given acceleration structure build should prioritize trace performance over build time.
VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV indicates that the given acceleration structure build should prioritize build time over trace performance.
VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV indicates that this acceleration structure should minimize the size of the scratch memory and the final result build, potentially at the expense of build time or trace performance.

Note

VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV and VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV may take more time and memory than a normal build, and so should only be used when those features are used.

typedef VkFlags VkBuildAccelerationStructureFlagsNV;

VkBuildAccelerationStructureFlagsNV is a bitmask type for setting a mask of zero or more VkBuildAccelerationStructureFlagBitsNV.

The VkGeometryNV structure is defined as:

typedef struct VkGeometryNV {
    VkStructureType      sType;
    const void*          pNext;
    VkGeometryTypeNV     geometryType;
    VkGeometryDataNV     geometry;
    VkGeometryFlagsNV    flags;
} VkGeometryNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
geometryType describes which type of geometry this VkGeometryNV refers to.
geometry contains the geometry data as described in VkGeometryDataNV.
flags has flags describing options for this geometry.

Valid Usage (Implicit)

VUID-VkGeometryNV-sType-sType
sType must be VK_STRUCTURE_TYPE_GEOMETRY_NV
VUID-VkGeometryNV-pNext-pNext
pNext must be NULL
VUID-VkGeometryNV-geometryType-parameter
geometryType must be a valid VkGeometryTypeNV value
VUID-VkGeometryNV-geometry-parameter
geometry must be a valid VkGeometryDataNV structure
VUID-VkGeometryNV-flags-parameter
flags must be a valid combination of VkGeometryFlagBitsNV values

Geometry types are specified by VkGeometryTypeNV, which takes values:

typedef enum VkGeometryTypeNV {
    VK_GEOMETRY_TYPE_TRIANGLES_NV = 0,
    VK_GEOMETRY_TYPE_AABBS_NV = 1,
    VK_GEOMETRY_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
} VkGeometryTypeNV;

VK_GEOMETRY_TYPE_TRIANGLES_NV indicates that the triangles of VkGeometryDataNV contains valid data.
VK_GEOMETRY_TYPE_AABBS_NV indicates that the aabbs of VkGeometryDataNV contains valid data.

Bits which can be set in VkGeometryNV::flags, specifying additional parameters for acceleration structure builds, are:

typedef enum VkGeometryFlagBitsNV {
    VK_GEOMETRY_OPAQUE_BIT_NV = 0x00000001,
    VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = 0x00000002,
    VK_GEOMETRY_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
} VkGeometryFlagBitsNV;

VK_GEOMETRY_OPAQUE_BIT_NV indicates that this geometry does not invoke the any-hit shaders even if present in a hit group.
VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV indicates that the implementation must only call the any-hit shader a single time for each primitive in this geometry. If this bit is absent an implementation may invoke the any-hit shader more than once for this geometry.

typedef VkFlags VkGeometryFlagsNV;

VkGeometryFlagsNV is a bitmask type for setting a mask of zero or more VkGeometryFlagBitsNV.

The VkGeometryDataNV structure is defined as:

typedef struct VkGeometryDataNV {
    VkGeometryTrianglesNV    triangles;
    VkGeometryAABBNV         aabbs;
} VkGeometryDataNV;

triangles contains triangle data if VkGeometryNV::geometryType is VK_GEOMETRY_TYPE_TRIANGLES_NV.
aabbs contains axis-aligned bounding box data if VkGeometryNV::geometryType is VK_GEOMETRY_TYPE_AABBS_NV.

Valid Usage (Implicit)

VUID-VkGeometryDataNV-triangles-parameter
triangles must be a valid VkGeometryTrianglesNV structure
VUID-VkGeometryDataNV-aabbs-parameter
aabbs must be a valid VkGeometryAABBNV structure

The VkGeometryTrianglesNV structure is defined as:

typedef struct VkGeometryTrianglesNV {
    VkStructureType    sType;
    const void*        pNext;
    VkBuffer           vertexData;
    VkDeviceSize       vertexOffset;
    uint32_t           vertexCount;
    VkDeviceSize       vertexStride;
    VkFormat           vertexFormat;
    VkBuffer           indexData;
    VkDeviceSize       indexOffset;
    uint32_t           indexCount;
    VkIndexType        indexType;
    VkBuffer           transformData;
    VkDeviceSize       transformOffset;
} VkGeometryTrianglesNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
vertexData is the buffer containing vertex data for this geometry.
vertexOffset is the offset in bytes within vertexData containing vertex data for this geometry.
vertexCount is the number of valid vertices.
vertexStride is the stride in bytes between each vertex.
vertexFormat is the format of each vertex element.
indexData is the buffer containing index data for this geometry.
indexOffset is the offset in bytes within indexData containing index data for this geometry.
indexCount is the number of indices to include in this geometry.
indexType is the format of each index.
transformData is a buffer containing optional reference to an array of 32-bit floats representing a 3x4 row major affine transformation matrix for this geometry.
transformOffset is the offset in bytes in transformData of the transform information described above.

If indexType is VK_INDEX_TYPE_NONE_NV, then this structure describes a set of triangles determined by vertexCount. Otherwise, this structure describes a set of indexed triangles determined by indexCount.

Valid Usage

VUID-VkGeometryTrianglesNV-vertexOffset-02428
vertexOffset must be less than the size of vertexData
VUID-VkGeometryTrianglesNV-vertexOffset-02429
vertexOffset must be a multiple of the component size of vertexFormat
VUID-VkGeometryTrianglesNV-vertexFormat-02430
vertexFormat must be one of VK_FORMAT_R32G32B32_SFLOAT, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R16G16B16_SFLOAT, VK_FORMAT_R16G16_SFLOAT, VK_FORMAT_R16G16_SNORM, or VK_FORMAT_R16G16B16_SNORM
VUID-VkGeometryTrianglesNV-indexOffset-02431
indexOffset must be less than the size of indexData
VUID-VkGeometryTrianglesNV-indexOffset-02432
indexOffset must be a multiple of the element size of indexType
VUID-VkGeometryTrianglesNV-indexType-02433
indexType must be VK_INDEX_TYPE_UINT16, VK_INDEX_TYPE_UINT32, or VK_INDEX_TYPE_NONE_NV
VUID-VkGeometryTrianglesNV-indexData-02434
indexData must be VK_NULL_HANDLE if indexType is VK_INDEX_TYPE_NONE_NV
VUID-VkGeometryTrianglesNV-indexData-02435
indexData must be a valid VkBuffer handle if indexType is not VK_INDEX_TYPE_NONE_NV
VUID-VkGeometryTrianglesNV-indexCount-02436
indexCount must be 0 if indexType is VK_INDEX_TYPE_NONE_NV
VUID-VkGeometryTrianglesNV-transformOffset-02437
transformOffset must be less than the size of transformData
VUID-VkGeometryTrianglesNV-transformOffset-02438
transformOffset must be a multiple of 16

Valid Usage (Implicit)

VUID-VkGeometryTrianglesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV
VUID-VkGeometryTrianglesNV-pNext-pNext
pNext must be NULL
VUID-VkGeometryTrianglesNV-vertexData-parameter
If vertexData is not VK_NULL_HANDLE, vertexData must be a valid VkBuffer handle
VUID-VkGeometryTrianglesNV-vertexFormat-parameter
vertexFormat must be a valid VkFormat value
VUID-VkGeometryTrianglesNV-indexData-parameter
If indexData is not VK_NULL_HANDLE, indexData must be a valid VkBuffer handle
VUID-VkGeometryTrianglesNV-indexType-parameter
indexType must be a valid VkIndexType value
VUID-VkGeometryTrianglesNV-transformData-parameter
If transformData is not VK_NULL_HANDLE, transformData must be a valid VkBuffer handle
VUID-VkGeometryTrianglesNV-commonparent
Each of indexData, transformData, and vertexData that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

The VkGeometryAABBNV structure is defined as:

typedef struct VkGeometryAABBNV {
    VkStructureType    sType;
    const void*        pNext;
    VkBuffer           aabbData;
    uint32_t           numAABBs;
    uint32_t           stride;
    VkDeviceSize       offset;
} VkGeometryAABBNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
aabbData is the buffer containing axis-aligned bounding box data.
numAABBs is the number of AABBs in this geometry.
stride is the stride in bytes between AABBs in aabbData.
offset is the offset in bytes of the first AABB in aabbData.

The AABB data in memory is six 32-bit floats consisting of the minimum x, y, and z values followed by the maximum x, y, and z values.

Valid Usage

VUID-VkGeometryAABBNV-offset-02439
offset must be less than the size of aabbData
VUID-VkGeometryAABBNV-offset-02440
offset must be a multiple of 8
VUID-VkGeometryAABBNV-stride-02441
stride must be a multiple of 8

Valid Usage (Implicit)

VUID-VkGeometryAABBNV-sType-sType
sType must be VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV
VUID-VkGeometryAABBNV-pNext-pNext
pNext must be NULL
VUID-VkGeometryAABBNV-aabbData-parameter
If aabbData is not VK_NULL_HANDLE, aabbData must be a valid VkBuffer handle

To destroy an acceleration structure, call:

void vkDestroyAccelerationStructureNV(
    VkDevice                                    device,
    VkAccelerationStructureNV                   accelerationStructure,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the buffer.
accelerationStructure is the acceleration structure to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyAccelerationStructureNV-accelerationStructure-02442
All submitted commands that refer to accelerationStructure must have completed execution
VUID-vkDestroyAccelerationStructureNV-accelerationStructure-02443
If VkAllocationCallbacks were provided when accelerationStructure was created, a compatible set of callbacks must be provided here
VUID-vkDestroyAccelerationStructureNV-accelerationStructure-02444
If no VkAllocationCallbacks were provided when accelerationStructure was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyAccelerationStructureNV-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyAccelerationStructureNV-accelerationStructure-parameter
accelerationStructure must be a valid VkAccelerationStructureNV handle
VUID-vkDestroyAccelerationStructureNV-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyAccelerationStructureNV-accelerationStructure-parent
accelerationStructure must have been created, allocated, or retrieved from device

An acceleration structure has memory requirements for the structure object itself, scratch space for the build, and scratch space for the update.

To query the memory requirements call:

void vkGetAccelerationStructureMemoryRequirementsNV(
    VkDevice                                    device,
    const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
    VkMemoryRequirements2KHR*                   pMemoryRequirements);

device is the logical device on which the acceleration structure was created.
pInfo specifies the acceleration structure to get memory requirements for.
pMemoryRequirements returns the requested acceleration structure memory requirements.

Valid Usage (Implicit)

VUID-vkGetAccelerationStructureMemoryRequirementsNV-device-parameter
device must be a valid VkDevice handle
VUID-vkGetAccelerationStructureMemoryRequirementsNV-pInfo-parameter
pInfo must be a valid pointer to a valid VkAccelerationStructureMemoryRequirementsInfoNV structure
VUID-vkGetAccelerationStructureMemoryRequirementsNV-pMemoryRequirements-parameter
pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2KHR structure

The VkAccelerationStructureMemoryRequirementsInfoNV structure is defined as:

typedef struct VkAccelerationStructureMemoryRequirementsInfoNV {
    VkStructureType                                    sType;
    const void*                                        pNext;
    VkAccelerationStructureMemoryRequirementsTypeNV    type;
    VkAccelerationStructureNV                          accelerationStructure;
} VkAccelerationStructureMemoryRequirementsInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
type selects the type of memory requirement being queried. VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV returns the memory requirements for the object itself. VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV returns the memory requirements for the scratch memory when doing a build. VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV returns the memory requirements for the scratch memory when doing an update.
accelerationStructure is the acceleration structure to be queried for memory requirements.

Valid Usage (Implicit)

VUID-VkAccelerationStructureMemoryRequirementsInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV
VUID-VkAccelerationStructureMemoryRequirementsInfoNV-pNext-pNext
pNext must be NULL
VUID-VkAccelerationStructureMemoryRequirementsInfoNV-type-parameter
type must be a valid VkAccelerationStructureMemoryRequirementsTypeNV value
VUID-VkAccelerationStructureMemoryRequirementsInfoNV-accelerationStructure-parameter
accelerationStructure must be a valid VkAccelerationStructureNV handle

Possible values of type in VkAccelerationStructureMemoryRequirementsInfoNV are:,

typedef enum VkAccelerationStructureMemoryRequirementsTypeNV {
    VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0,
    VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1,
    VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2,
    VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
} VkAccelerationStructureMemoryRequirementsTypeNV;

VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV requests the memory requirement for the VkAccelerationStructureNV backing store.
VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV requests the memory requirement for scratch space during the initial build.
VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV requests the memory requirement for scratch space during an update.

To attach memory to one or more acceleration structures at a time, call:

VkResult vkBindAccelerationStructureMemoryNV(
    VkDevice                                    device,
    uint32_t                                    bindInfoCount,
    const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);

device is the logical device that owns the acceleration structures and memory.
bindInfoCount is the number of elements in pBindInfos.
pBindInfos is a pointer to an array of VkBindAccelerationStructureMemoryInfoNV structures describing images and memory to bind.

Valid Usage (Implicit)

VUID-vkBindAccelerationStructureMemoryNV-device-parameter
device must be a valid VkDevice handle
VUID-vkBindAccelerationStructureMemoryNV-pBindInfos-parameter
pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindAccelerationStructureMemoryInfoNV structures
VUID-vkBindAccelerationStructureMemoryNV-bindInfoCount-arraylength
bindInfoCount must be greater than 0

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkBindAccelerationStructureMemoryInfoNV structure is defined as:

typedef struct VkBindAccelerationStructureMemoryInfoNV {
    VkStructureType              sType;
    const void*                  pNext;
    VkAccelerationStructureNV    accelerationStructure;
    VkDeviceMemory               memory;
    VkDeviceSize                 memoryOffset;
    uint32_t                     deviceIndexCount;
    const uint32_t*              pDeviceIndices;
} VkBindAccelerationStructureMemoryInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
accelerationStructure is the acceleration structure to be attached to memory.
memory is a VkDeviceMemory object describing the device memory to attach.
memoryOffset is the start offset of the region of memory that is to be bound to the acceleration structure. The number of bytes returned in the VkMemoryRequirements::size member in memory, starting from memoryOffset bytes, will be bound to the specified acceleration structure.
deviceIndexCount is the number of elements in pDeviceIndices.
pDeviceIndices is a pointer to an array of device indices.

Valid Usage

VUID-VkBindAccelerationStructureMemoryInfoNV-accelerationStructure-02450
accelerationStructure must not already be backed by a memory object
VUID-VkBindAccelerationStructureMemoryInfoNV-memoryOffset-02451
memoryOffset must be less than the size of memory
VUID-VkBindAccelerationStructureMemoryInfoNV-memory-02593
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 vkGetAccelerationStructureMemoryRequirementsNV with accelerationStructure and type of VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV
VUID-VkBindAccelerationStructureMemoryInfoNV-memoryOffset-02594
memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with accelerationStructure and type of VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV
VUID-VkBindAccelerationStructureMemoryInfoNV-size-02595
The size member of the VkMemoryRequirements structure returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with accelerationStructure and type of VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV must be less than or equal to the size of memory minus memoryOffset

Valid Usage (Implicit)

VUID-VkBindAccelerationStructureMemoryInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV
VUID-VkBindAccelerationStructureMemoryInfoNV-pNext-pNext
pNext must be NULL
VUID-VkBindAccelerationStructureMemoryInfoNV-accelerationStructure-parameter
accelerationStructure must be a valid VkAccelerationStructureNV handle
VUID-VkBindAccelerationStructureMemoryInfoNV-memory-parameter
memory must be a valid VkDeviceMemory handle
VUID-VkBindAccelerationStructureMemoryInfoNV-pDeviceIndices-parameter
If deviceIndexCount is not 0, pDeviceIndices must be a valid pointer to an array of deviceIndexCount uint32_t values
VUID-VkBindAccelerationStructureMemoryInfoNV-commonparent
Both of accelerationStructure, and memory must have been created, allocated, or retrieved from the same VkDevice

To allow constructing geometry instances with device code if desired, we need to be able to query a opaque handle for an acceleration structure. This handle is a value of 8 bytes. To get this handle, call:

VkResult vkGetAccelerationStructureHandleNV(
    VkDevice                                    device,
    VkAccelerationStructureNV                   accelerationStructure,
    size_t                                      dataSize,
    void*                                       pData);

device is the logical device that owns the acceleration structures.
accelerationStructure is the acceleration structure.
dataSize is the size in bytes of the buffer pointed to by pData.
pData is a pointer to a user-allocated buffer where the results will be written.

Valid Usage

VUID-vkGetAccelerationStructureHandleNV-dataSize-02240
dataSize must be large enough to contain the result of the query, as described above
VUID-vkGetAccelerationStructureHandleNV-accelerationStructure-02787
accelerationStructure must be bound completely and contiguously to a single VkDeviceMemory object via vkBindAccelerationStructureMemoryNV

Valid Usage (Implicit)

VUID-vkGetAccelerationStructureHandleNV-device-parameter
device must be a valid VkDevice handle
VUID-vkGetAccelerationStructureHandleNV-accelerationStructure-parameter
accelerationStructure must be a valid VkAccelerationStructureNV handle
VUID-vkGetAccelerationStructureHandleNV-pData-parameter
pData must be a valid pointer to an array of dataSize bytes
VUID-vkGetAccelerationStructureHandleNV-dataSize-arraylength
dataSize must be greater than 0
VUID-vkGetAccelerationStructureHandleNV-accelerationStructure-parent
accelerationStructure must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

12. Samplers

VkSampler objects represent 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.

Samplers are represented by VkSampler handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)

To create a sampler object, call:

VkResult vkCreateSampler(
    VkDevice                                    device,
    const VkSamplerCreateInfo*                  pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSampler*                                  pSampler);

device is the logical device that creates the sampler.
pCreateInfo is a pointer to a VkSamplerCreateInfo structure specifying the state of the sampler object.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pSampler is a pointer to a VkSampler handle in which the resulting sampler object is returned.

Valid Usage (Implicit)

VUID-vkCreateSampler-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateSampler-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkSamplerCreateInfo structure
VUID-vkCreateSampler-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateSampler-pSampler-parameter
pSampler must be a valid pointer to a VkSampler handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_TOO_MANY_OBJECTS

The VkSamplerCreateInfo structure is defined as:

typedef struct VkSamplerCreateInfo {
    VkStructureType         sType;
    const void*             pNext;
    VkSamplerCreateFlags    flags;
    VkFilter                magFilter;
    VkFilter                minFilter;
    VkSamplerMipmapMode     mipmapMode;
    VkSamplerAddressMode    addressModeU;
    VkSamplerAddressMode    addressModeV;
    VkSamplerAddressMode    addressModeW;
    float                   mipLodBias;
    VkBool32                anisotropyEnable;
    float                   maxAnisotropy;
    VkBool32                compareEnable;
    VkCompareOp             compareOp;
    float                   minLod;
    float                   maxLod;
    VkBorderColor           borderColor;
    VkBool32                unnormalizedCoordinates;
} VkSamplerCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkSamplerCreateFlagBits describing additional parameters of the sampler.
magFilter is a VkFilter value specifying the magnification filter to apply to lookups.
minFilter is a VkFilter value specifying the minification filter to apply to lookups.
mipmapMode is a VkSamplerMipmapMode value specifying the mipmap filter to apply to lookups.
addressModeU is a VkSamplerAddressMode value specifying the addressing mode for outside [0..1] range for U coordinate.
addressModeV is a VkSamplerAddressMode value specifying the addressing mode for outside [0..1] range for V coordinate.
addressModeW is a VkSamplerAddressMode value specifying the addressing mode for outside [0..1] range for W coordinate.
mipLodBias is the bias to be added to mipmap LOD (level-of-detail) calculation and bias provided by image sampling functions in SPIR-V, as described in the Level-of-Detail Operation section.
anisotropyEnable is VK_TRUE to enable anisotropic filtering, as described in the Texel Anisotropic Filtering section, or VK_FALSE otherwise.
maxAnisotropy is the anisotropy value clamp used by the sampler when anisotropyEnable is VK_TRUE. If anisotropyEnable is VK_FALSE, maxAnisotropy is ignored.
compareEnable is VK_TRUE to enable comparison against a reference value during lookups, or VK_FALSE otherwise.
- Note: Some implementations will default to shader state if this member does not match.
compareOp is a VkCompareOp value specifying the comparison function to apply to fetched data before filtering as described in the Depth Compare Operation section.
minLod and maxLod are the values used to clamp the computed LOD value, as described in the Level-of-Detail Operation section.
borderColor is a VkBorderColor value specifying the predefined border color to use.
unnormalizedCoordinates controls whether to use unnormalized or normalized texel coordinates to address texels of the image. When set to VK_TRUE, the range of the image coordinates used to lookup the texel is in the range of zero to the image dimensions for x, y and z. When set to VK_FALSE the range of image coordinates is zero to one.

When unnormalizedCoordinates is VK_TRUE, images the sampler is used with in the shader have the following requirements:
- The viewType must be either VK_IMAGE_VIEW_TYPE_1D or VK_IMAGE_VIEW_TYPE_2D.
- The image view must have a single layer and a single mip level.
When unnormalizedCoordinates is VK_TRUE, image built-in functions in the shader that use the sampler have the following requirements:
- The functions must not use projection.
- The functions must not use offsets.

Mapping of OpenGL to Vulkan filter modes

magFilter values of VK_FILTER_NEAREST and VK_FILTER_LINEAR directly correspond to GL_NEAREST and GL_LINEAR magnification filters. minFilter and mipmapMode combine to correspond to the similarly named OpenGL minification filter of GL_minFilter_MIPMAP_mipmapMode (e.g. minFilter of VK_FILTER_LINEAR and mipmapMode of VK_SAMPLER_MIPMAP_MODE_NEAREST correspond to GL_LINEAR_MIPMAP_NEAREST).

There are no Vulkan filter modes that directly correspond to OpenGL minification filters of GL_LINEAR or GL_NEAREST, but they can be emulated using VK_SAMPLER_MIPMAP_MODE_NEAREST, minLod = 0, and maxLod = 0.25, and using minFilter = VK_FILTER_LINEAR or minFilter = VK_FILTER_NEAREST, respectively.

Note that using a maxLod of zero would cause magnification to always be performed, and the magFilter to always be used. This is valid, just not an exact match for OpenGL behavior. Clamping the maximum LOD to 0.25 allows the λ value to be non-zero and minification to be performed, while still always rounding down to the base level. If the minFilter and magFilter are equal, then using a maxLod of zero also works.

The maximum number of sampler objects which can be simultaneously created on a device is implementation-dependent and specified by the maxSamplerAllocationCount member of the VkPhysicalDeviceLimits structure. If maxSamplerAllocationCount is exceeded, vkCreateSampler will return VK_ERROR_TOO_MANY_OBJECTS.

Since VkSampler is a non-dispatchable handle type, implementations may return the same handle for sampler state vectors that are identical. In such cases, all such objects would only count once against the maxSamplerAllocationCount limit.

Valid Usage

VUID-VkSamplerCreateInfo-mipLodBias-01069
The absolute value of mipLodBias must be less than or equal to VkPhysicalDeviceLimits::maxSamplerLodBias
VUID-VkSamplerCreateInfo-maxLod-01973
maxLod must be greater than or equal to minLod
VUID-VkSamplerCreateInfo-anisotropyEnable-01070
If the anisotropic sampling feature is not enabled, anisotropyEnable must be VK_FALSE
VUID-VkSamplerCreateInfo-anisotropyEnable-01071
If anisotropyEnable is VK_TRUE, maxAnisotropy must be between 1.0 and VkPhysicalDeviceLimits::maxSamplerAnisotropy, inclusive
VUID-VkSamplerCreateInfo-minFilter-01645
If sampler Y′C_BC_R conversion is enabled and VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT is not set for the format, minFilter and magFilter must be equal to the sampler Y′C_BC_R conversion’s chromaFilter
VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01072
If unnormalizedCoordinates is VK_TRUE, minFilter and magFilter must be equal
VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01073
If unnormalizedCoordinates is VK_TRUE, mipmapMode must be VK_SAMPLER_MIPMAP_MODE_NEAREST
VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01074
If unnormalizedCoordinates is VK_TRUE, minLod and maxLod must be zero
VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01075
If unnormalizedCoordinates is VK_TRUE, addressModeU and addressModeV must each be either VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE or VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER
VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01076
If unnormalizedCoordinates is VK_TRUE, anisotropyEnable must be VK_FALSE
VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01077
If unnormalizedCoordinates is VK_TRUE, compareEnable must be VK_FALSE
VUID-VkSamplerCreateInfo-addressModeU-01078
If any of addressModeU, addressModeV or addressModeW are VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, borderColor must be a valid VkBorderColor value
VUID-VkSamplerCreateInfo-addressModeU-01646
If sampler Y′C_BC_R conversion is enabled, addressModeU, addressModeV, and addressModeW must be VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, anisotropyEnable must be VK_FALSE, and unnormalizedCoordinates must be VK_FALSE
VUID-VkSamplerCreateInfo-None-01647
The sampler reduction mode must be set to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE if sampler Y′C_BC_R conversion is enabled
VUID-VkSamplerCreateInfo-addressModeU-01079
If samplerMirrorClampToEdge is not enabled, and if the [VK_KHR_sampler_mirror_clamp_to_edge] extension is not enabled, addressModeU, addressModeV and addressModeW must not be VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE
VUID-VkSamplerCreateInfo-compareEnable-01080
If compareEnable is VK_TRUE, compareOp must be a valid VkCompareOp value
VUID-VkSamplerCreateInfo-magFilter-01081
If either magFilter or minFilter is VK_FILTER_CUBIC_EXT, anisotropyEnable must be VK_FALSE
VUID-VkSamplerCreateInfo-compareEnable-01423
If compareEnable is VK_TRUE, the reductionMode member of VkSamplerReductionModeCreateInfo must be VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE
VUID-VkSamplerCreateInfo-flags-02574
If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then minFilter and magFilter must be equal.
VUID-VkSamplerCreateInfo-flags-02575
If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then mipmapMode must be VK_SAMPLER_MIPMAP_MODE_NEAREST.
VUID-VkSamplerCreateInfo-flags-02576
If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then minLod and maxLod must be zero.
VUID-VkSamplerCreateInfo-flags-02577
If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then addressModeU and addressModeV must each be either VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE or VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER.
VUID-VkSamplerCreateInfo-flags-02578
If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then anisotropyEnable must be VK_FALSE.
VUID-VkSamplerCreateInfo-flags-02579
If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then compareEnable must be VK_FALSE.
VUID-VkSamplerCreateInfo-flags-02580
If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then unnormalizedCoordinates must be VK_FALSE.

Valid Usage (Implicit)

VUID-VkSamplerCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
VUID-VkSamplerCreateInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkSamplerReductionModeCreateInfo or VkSamplerYcbcrConversionInfo
VUID-VkSamplerCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkSamplerCreateInfo-flags-parameter
flags must be a valid combination of VkSamplerCreateFlagBits values
VUID-VkSamplerCreateInfo-magFilter-parameter
magFilter must be a valid VkFilter value
VUID-VkSamplerCreateInfo-minFilter-parameter
minFilter must be a valid VkFilter value
VUID-VkSamplerCreateInfo-mipmapMode-parameter
mipmapMode must be a valid VkSamplerMipmapMode value
VUID-VkSamplerCreateInfo-addressModeU-parameter
addressModeU must be a valid VkSamplerAddressMode value
VUID-VkSamplerCreateInfo-addressModeV-parameter
addressModeV must be a valid VkSamplerAddressMode value
VUID-VkSamplerCreateInfo-addressModeW-parameter
addressModeW must be a valid VkSamplerAddressMode value

Bits which can be set in VkSamplerCreateInfo::flags, specifying additional parameters of a sampler, are:

typedef enum VkSamplerCreateFlagBits {
    VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001,
    VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002,
    VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkSamplerCreateFlagBits;

VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT specifies that the sampler will read from an image created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT.
VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT specifies that the implementation may use approximations when reconstructing a full color value for texture access from a subsampled image.

Note

The approximations used when VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT is specified are implementation defined. Some implementations may interpolate between fragment density levels in a subsampled image. In that case, this bit may be used to decide whether the interpolation factors are calculated per fragment or at a coarser granularity.

typedef VkFlags VkSamplerCreateFlags;

VkSamplerCreateFlags is a bitmask type for setting a mask of zero or more VkSamplerCreateFlagBits.

The VkSamplerReductionModeCreateInfo structure is defined as:

typedef struct VkSamplerReductionModeCreateInfo {
    VkStructureType           sType;
    const void*               pNext;
    VkSamplerReductionMode    reductionMode;
} VkSamplerReductionModeCreateInfo;

or the equivalent

typedef VkSamplerReductionModeCreateInfo VkSamplerReductionModeCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
reductionMode is a VkSamplerReductionMode value controlling how texture filtering combines texel values.

If the pNext chain of VkSamplerCreateInfo includes a VkSamplerReductionModeCreateInfo structure, then that structure includes a mode that controls how texture filtering combines texel values.

If this structure is not present, reductionMode is considered to be VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE.

Valid Usage (Implicit)

VUID-VkSamplerReductionModeCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO
VUID-VkSamplerReductionModeCreateInfo-reductionMode-parameter
reductionMode must be a valid VkSamplerReductionMode value

Reduction modes are specified by VkSamplerReductionMode, which takes values:

typedef enum VkSamplerReductionMode {
    VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0,
    VK_SAMPLER_REDUCTION_MODE_MIN = 1,
    VK_SAMPLER_REDUCTION_MODE_MAX = 2,
    VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE,
    VK_SAMPLER_REDUCTION_MODE_MIN_EXT = VK_SAMPLER_REDUCTION_MODE_MIN,
    VK_SAMPLER_REDUCTION_MODE_MAX_EXT = VK_SAMPLER_REDUCTION_MODE_MAX,
    VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF
} VkSamplerReductionMode;

or the equivalent

typedef VkSamplerReductionMode VkSamplerReductionModeEXT;

VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE specifies that texel values are combined by computing a weighted average of values in the footprint, using weights as specified in the image operations chapter.
VK_SAMPLER_REDUCTION_MODE_MIN specifies that texel values are combined by taking the component-wise minimum of values in the footprint with non-zero weights.
VK_SAMPLER_REDUCTION_MODE_MAX specifies that texel values are combined by taking the component-wise maximum of values in the footprint with non-zero weights.

Possible values of the VkSamplerCreateInfo::magFilter and minFilter parameters, specifying filters used for texture lookups, are:

typedef enum VkFilter {
    VK_FILTER_NEAREST = 0,
    VK_FILTER_LINEAR = 1,
    VK_FILTER_CUBIC_IMG = 1000015000,
    VK_FILTER_CUBIC_EXT = VK_FILTER_CUBIC_IMG,
    VK_FILTER_MAX_ENUM = 0x7FFFFFFF
} VkFilter;

VK_FILTER_NEAREST specifies nearest filtering.
VK_FILTER_LINEAR specifies linear filtering.
VK_FILTER_CUBIC_EXT specifies cubic filtering.

These filters are described in detail in Texel Filtering.

Possible values of the VkSamplerCreateInfo::mipmapMode, specifying the mipmap mode used for texture lookups, are:

typedef enum VkSamplerMipmapMode {
    VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
    VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
    VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
} VkSamplerMipmapMode;

VK_SAMPLER_MIPMAP_MODE_NEAREST specifies nearest filtering.
VK_SAMPLER_MIPMAP_MODE_LINEAR specifies linear filtering.

These modes are described in detail in Texel Filtering.

Possible values of the VkSamplerCreateInfo::addressMode* parameters, specifying the behavior of sampling with coordinates outside the range [0,1] for the respective u, v, or w coordinate as defined in the Wrapping Operation section, are:

typedef enum VkSamplerAddressMode {
    VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
    VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
    VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
    VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
    VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
} VkSamplerAddressMode;

VK_SAMPLER_ADDRESS_MODE_REPEAT specifies that the repeat wrap mode will be used.
VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT specifies that the mirrored repeat wrap mode will be used.
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE specifies that the clamp to edge wrap mode will be used.
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER specifies that the clamp to border wrap mode will be used.
VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE specifies that the mirror clamp to edge wrap mode will be used. This is only valid if samplerMirrorClampToEdge is enabled, or if the [VK_KHR_sampler_mirror_clamp_to_edge] extension is enabled.

Possible values of VkSamplerCreateInfo::borderColor, specifying the border color used for texture lookups, are:

typedef enum VkBorderColor {
    VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
    VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
    VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
    VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
    VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
    VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
    VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
} VkBorderColor;

VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK specifies a transparent, floating-point format, black color.
VK_BORDER_COLOR_INT_TRANSPARENT_BLACK specifies a transparent, integer format, black color.
VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK specifies an opaque, floating-point format, black color.
VK_BORDER_COLOR_INT_OPAQUE_BLACK specifies an opaque, integer format, black color.
VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE specifies an opaque, floating-point format, white color.
VK_BORDER_COLOR_INT_OPAQUE_WHITE specifies an opaque, integer format, white color.

These colors are described in detail in Texel Replacement.

To destroy a sampler, call:

void vkDestroySampler(
    VkDevice                                    device,
    VkSampler                                   sampler,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the sampler.
sampler is the sampler to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroySampler-sampler-01082
All submitted commands that refer to sampler must have completed execution
VUID-vkDestroySampler-sampler-01083
If VkAllocationCallbacks were provided when sampler was created, a compatible set of callbacks must be provided here
VUID-vkDestroySampler-sampler-01084
If no VkAllocationCallbacks were provided when sampler was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroySampler-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroySampler-sampler-parameter
If sampler is not VK_NULL_HANDLE, sampler must be a valid VkSampler handle
VUID-vkDestroySampler-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroySampler-sampler-parent
If sampler is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to sampler must be externally synchronized

12.1. Sampler Y′C_BC_R conversion

To create a sampler with Y′C_BC_R conversion enabled, add a VkSamplerYcbcrConversionInfo structure to the pNext chain of the VkSamplerCreateInfo structure. To create a sampler Y′C_BC_R conversion, the samplerYcbcrConversion feature must be enabled. Conversion must be fixed at pipeline creation time, through use of a combined image sampler with an immutable sampler in VkDescriptorSetLayoutBinding.

A VkSamplerYcbcrConversionInfo must be provided for samplers to be used with image views that access VK_IMAGE_ASPECT_COLOR_BIT if the format appears in Formats requiring sampler Y′C_BC_R conversion for VK_IMAGE_ASPECT_COLOR_BIT image views , or if the image view has an external format .

The VkSamplerYcbcrConversionInfo structure is defined as:

typedef struct VkSamplerYcbcrConversionInfo {
    VkStructureType             sType;
    const void*                 pNext;
    VkSamplerYcbcrConversion    conversion;
} VkSamplerYcbcrConversionInfo;

or the equivalent

typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
conversion is a VkSamplerYcbcrConversion handle created with vkCreateSamplerYcbcrConversion.

Valid Usage (Implicit)

VUID-VkSamplerYcbcrConversionInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO
VUID-VkSamplerYcbcrConversionInfo-conversion-parameter
conversion must be a valid VkSamplerYcbcrConversion handle

A sampler Y′C_BC_R conversion is an opaque representation of a device-specific sampler Y′C_BC_R conversion description, represented as a VkSamplerYcbcrConversion handle:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion)

or the equivalent

typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR;

To create a VkSamplerYcbcrConversion, call:

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

or the equivalent command

VkResult vkCreateSamplerYcbcrConversionKHR(
    VkDevice                                    device,
    const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSamplerYcbcrConversion*                   pYcbcrConversion);

device is the logical device that creates the sampler Y′C_BC_R conversion.
pCreateInfo is a pointer to a VkSamplerYcbcrConversionCreateInfo structure specifying the requested sampler Y′C_BC_R conversion.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pYcbcrConversion is a pointer to a VkSamplerYcbcrConversion handle in which the resulting sampler Y′C_BC_R conversion is returned.

The interpretation of the configured sampler Y′C_BC_R conversion is described in more detail in the description of sampler Y′C_BC_R conversion in the Image Operations chapter.

Valid Usage

VUID-vkCreateSamplerYcbcrConversion-None-01648
The sampler Y′C_BC_R conversion feature must be enabled

Valid Usage (Implicit)

VUID-vkCreateSamplerYcbcrConversion-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateSamplerYcbcrConversion-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkSamplerYcbcrConversionCreateInfo structure
VUID-vkCreateSamplerYcbcrConversion-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateSamplerYcbcrConversion-pYcbcrConversion-parameter
pYcbcrConversion must be a valid pointer to a VkSamplerYcbcrConversion handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkSamplerYcbcrConversionCreateInfo structure is defined as:

typedef struct VkSamplerYcbcrConversionCreateInfo {
    VkStructureType                  sType;
    const void*                      pNext;
    VkFormat                         format;
    VkSamplerYcbcrModelConversion    ycbcrModel;
    VkSamplerYcbcrRange              ycbcrRange;
    VkComponentMapping               components;
    VkChromaLocation                 xChromaOffset;
    VkChromaLocation                 yChromaOffset;
    VkFilter                         chromaFilter;
    VkBool32                         forceExplicitReconstruction;
} VkSamplerYcbcrConversionCreateInfo;

or the equivalent

typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
format is the format of the image from which color information will be retrieved.
ycbcrModel describes the color matrix for conversion between color models.
ycbcrRange describes whether the encoded values have headroom and foot room, or whether the encoding uses the full numerical range.
components applies a swizzle based on VkComponentSwizzle enums prior to range expansion and color model conversion.
xChromaOffset describes the sample location associated with downsampled chroma channels in the x dimension. xChromaOffset has no effect for formats in which chroma channels are the same resolution as the luma channel.
yChromaOffset describes the sample location associated with downsampled chroma channels in the y dimension. yChromaOffset has no effect for formats in which the chroma channels are not downsampled vertically.
chromaFilter is the filter for chroma reconstruction.
forceExplicitReconstruction can be used to ensure that reconstruction is done explicitly, if supported.

Note

Setting forceExplicitReconstruction to VK_TRUE may have a performance penalty on implementations where explicit reconstruction is not the default mode of operation.

If format supports VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT the forceExplicitReconstruction value behaves as if it was set to VK_TRUE.

If the pNext chain includes a VkExternalFormatANDROID structure with non-zero externalFormat member, the sampler Y′C_BC_R conversion object represents an external format conversion, and format must be VK_FORMAT_UNDEFINED. Such conversions must only be used to sample image views with a matching external format. When creating an external format conversion, the value of components is ignored.

Valid Usage

VUID-VkSamplerYcbcrConversionCreateInfo-format-01904
If an external format conversion is being created, format must be VK_FORMAT_UNDEFINED, otherwise it must not be VK_FORMAT_UNDEFINED.
VUID-VkSamplerYcbcrConversionCreateInfo-format-01650
format must support VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT or VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT
VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-01651
If the format does not support VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, xChromaOffset and yChromaOffset must not be VK_CHROMA_LOCATION_COSITED_EVEN
VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-01652
If the format does not support VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, xChromaOffset and yChromaOffset must not be VK_CHROMA_LOCATION_MIDPOINT
VUID-VkSamplerYcbcrConversionCreateInfo-format-01653
format must represent unsigned normalized values (i.e. the format must be a UNORM format)
VUID-VkSamplerYcbcrConversionCreateInfo-components-02581
If the format has a _422 or _420 suffix, then components.g must be VK_COMPONENT_SWIZZLE_IDENTITY
VUID-VkSamplerYcbcrConversionCreateInfo-components-02582
If the format has a _422 or _420 suffix, then components.a must be VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_ONE, or VK_COMPONENT_SWIZZLE_ZERO
VUID-VkSamplerYcbcrConversionCreateInfo-components-02583
If the format has a _422 or _420 suffix, then components.r must be VK_COMPONENT_SWIZZLE_IDENTITY or VK_COMPONENT_SWIZZLE_B
VUID-VkSamplerYcbcrConversionCreateInfo-components-02584
If the format has a _422 or _420 suffix, then components.b must be VK_COMPONENT_SWIZZLE_IDENTITY or VK_COMPONENT_SWIZZLE_R
VUID-VkSamplerYcbcrConversionCreateInfo-components-02585
If the format has a _422 or _420 suffix, and if either components.r or components.b is VK_COMPONENT_SWIZZLE_IDENTITY, both values must be VK_COMPONENT_SWIZZLE_IDENTITY
VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-01655
If ycbcrModel is not VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, then components.r, components.g, and components.b must correspond to channels of the format; that is, components.r, components.g, and components.b must not be VK_COMPONENT_SWIZZLE_ZERO or VK_COMPONENT_SWIZZLE_ONE, and must not correspond to a channel which contains zero or one as a consequence of conversion to RGBA
VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-02748
If ycbcrRange is VK_SAMPLER_YCBCR_RANGE_ITU_NARROW then the R, G and B channels obtained by applying the component swizzle to format must each have a bit-depth greater than or equal to 8.
VUID-VkSamplerYcbcrConversionCreateInfo-forceExplicitReconstruction-01656
If the format does not support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT forceExplicitReconstruction must be VK_FALSE
VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-01657
If the format does not support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, chromaFilter must not be VK_FILTER_LINEAR

Valid Usage (Implicit)

VUID-VkSamplerYcbcrConversionCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO
VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkExternalFormatANDROID
VUID-VkSamplerYcbcrConversionCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkSamplerYcbcrConversionCreateInfo-format-parameter
format must be a valid VkFormat value
VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-parameter
ycbcrModel must be a valid VkSamplerYcbcrModelConversion value
VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-parameter
ycbcrRange must be a valid VkSamplerYcbcrRange value
VUID-VkSamplerYcbcrConversionCreateInfo-components-parameter
components must be a valid VkComponentMapping structure
VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-parameter
xChromaOffset must be a valid VkChromaLocation value
VUID-VkSamplerYcbcrConversionCreateInfo-yChromaOffset-parameter
yChromaOffset must be a valid VkChromaLocation value
VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-parameter
chromaFilter must be a valid VkFilter value

If chromaFilter is VK_FILTER_NEAREST, chroma samples are reconstructed to luma channel resolution using nearest-neighbour sampling. Otherwise, chroma samples are reconstructed using interpolation. More details can be found in the description of sampler Y′C_BC_R conversion in the Image Operations chapter.

VkSamplerYcbcrModelConversion defines the conversion from the source color model to the shader color model. Possible values are:

typedef enum VkSamplerYcbcrModelConversion {
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF
} VkSamplerYcbcrModelConversion;

or the equivalent

typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR;

VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY specifies that the input values to the conversion are unmodified.
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY specifies no model conversion but the inputs are range expanded as for Y′C_BC_R.
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 specifies the color model conversion from Y′C_BC_R to R′G′B′ defined in BT.709 and described in the “BT.709 Y’C_BC_R conversion” section of the Khronos Data Format Specification.
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 specifies the color model conversion from Y′C_BC_R to R′G′B′ defined in BT.601 and described in the “BT.601 Y’C_BC_R conversion” section of the Khronos Data Format Specification.
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 specifies the color model conversion from Y′C_BC_R to R′G′B′ defined in BT.2020 and described in the “BT.2020 Y’C_BC_R conversion” section of the Khronos Data Format Specification.

In the VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_* color models, for the input to the sampler Y′C_BC_R range expansion and model conversion:

the Y (Y′ luma) channel corresponds to the G channel of an RGB image.
the CB (C_B or “U” blue color difference) channel corresponds to the B channel of an RGB image.
the CR (C_R or “V” red color difference) channel corresponds to the R channel of an RGB image.
the alpha channel, if present, is not modified by color model conversion.

These rules reflect the mapping of channels after the channel swizzle operation (controlled by VkSamplerYcbcrConversionCreateInfo::components).

Note

For example, an “YUVA” 32-bit format comprising four 8-bit channels can be implemented as VK_FORMAT_R8G8B8A8_UNORM with a component mapping:

components.a = VK_COMPONENT_SWIZZLE_IDENTITY
components.r = VK_COMPONENT_SWIZZLE_B
components.g = VK_COMPONENT_SWIZZLE_R
components.b = VK_COMPONENT_SWIZZLE_G

The VkSamplerYcbcrRange enum describes whether color channels are encoded using the full range of numerical values or whether values are reserved for headroom and foot room. VkSamplerYcbcrRange is defined as:

typedef enum VkSamplerYcbcrRange {
    VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0,
    VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1,
    VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
    VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
    VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF
} VkSamplerYcbcrRange;

or the equivalent

typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR;

VK_SAMPLER_YCBCR_RANGE_ITU_FULL specifies that the full range of the encoded values are valid and interpreted according to the ITU “full range” quantization rules.
VK_SAMPLER_YCBCR_RANGE_ITU_NARROW specifies that headroom and foot room are reserved in the numerical range of encoded values, and the remaining values are expanded according to the ITU “narrow range” quantization rules.

The formulae for these conversions is described in the Sampler Y′C_BC_R Range Expansion section of the Image Operations chapter.

No range modification takes place if ycbcrModel is VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY; the ycbcrRange field of VkSamplerYcbcrConversionCreateInfo is ignored in this case.

The VkChromaLocation enum defines the location of downsampled chroma channel samples relative to the luma samples, and is defined as:

typedef enum VkChromaLocation {
    VK_CHROMA_LOCATION_COSITED_EVEN = 0,
    VK_CHROMA_LOCATION_MIDPOINT = 1,
    VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN,
    VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT,
    VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF
} VkChromaLocation;

or the equivalent

typedef VkChromaLocation VkChromaLocationKHR;

VK_CHROMA_LOCATION_COSITED_EVEN specifies that downsampled chroma samples are aligned with luma samples with even coordinates.
VK_CHROMA_LOCATION_MIDPOINT specifies that downsampled chroma samples are located half way between each even luma sample and the nearest higher odd luma sample.

To destroy a sampler Y′C_BC_R conversion, call:

void vkDestroySamplerYcbcrConversion(
    VkDevice                                    device,
    VkSamplerYcbcrConversion                    ycbcrConversion,
    const VkAllocationCallbacks*                pAllocator);

or the equivalent command

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

device is the logical device that destroys the Y′C_BC_R conversion.
ycbcrConversion is the conversion to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage (Implicit)

VUID-vkDestroySamplerYcbcrConversion-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parameter
If ycbcrConversion is not VK_NULL_HANDLE, ycbcrConversion must be a valid VkSamplerYcbcrConversion handle
VUID-vkDestroySamplerYcbcrConversion-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parent
If ycbcrConversion is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to ycbcrConversion must be externally synchronized

13. Resource Descriptors

A descriptor is an opaque data structure representing a shader resource such as a buffer, buffer view, image view, sampler, or combined image sampler. Descriptors are organised into descriptor sets, which are bound during command recording for use in subsequent draw commands. The arrangement of content in each descriptor set is determined by a descriptor set layout, which determines what descriptors can be stored within it. The sequence of descriptor set layouts that can be used by a pipeline is specified in a pipeline layout. Each pipeline object can use up to maxBoundDescriptorSets (see Limits) descriptor sets.

Shaders access resources via variables decorated with a descriptor set and binding number that link them to a descriptor in a descriptor set. The shader interface mapping to bound descriptor sets is described in the Shader Resource Interface section.

Shaders can also access buffers without going through descriptors by using Physical Storage Buffer Access to access them through 64-bit addresses.

13.1. Descriptor Types

There are a number of different types of descriptor supported by Vulkan, corresponding to different resources or usage. The following sections describe the API definitions of each descriptor type. The mapping of each type to SPIR-V is listed in the Shader Resource and Descriptor Type Correspondence and Shader Resource and Storage Class Correspondence tables in the Shader Interfaces chapter.

13.1.1. Storage Image

A storage image (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) is a descriptor type associated with an image resource via an image view that load, store, and atomic operations can be performed on.

Storage image loads are supported in all shader stages for image views whose format features contain VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT.

Stores to storage images are supported in compute shaders for image views whose format features contain VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT.

Atomic operations on storage images are supported in compute shaders for image views whose format features contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT.

When the fragmentStoresAndAtomics feature is enabled, stores and atomic operations are also supported for storage images in fragment shaders with the same set of image formats as supported in compute shaders. When the vertexPipelineStoresAndAtomics feature is enabled, stores and atomic operations are also supported in vertex, tessellation, and geometry shaders with the same set of image formats as supported in compute shaders.

The image subresources for a storage image must be in the VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR or VK_IMAGE_LAYOUT_GENERAL layout in order to access its data in a shader.

13.1.2. Sampler

A sampler descriptor (VK_DESCRIPTOR_TYPE_SAMPLER) is a descriptor type associated with a sampler object, used to control the behavior of sampling operations performed on a sampled image.

13.1.3. Sampled Image

A sampled image (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) is a descriptor type associated with an image resource via an image view that sampling operations can be performed on.

Shaders combine a sampled image variable and a sampler variable to perform sampling operations.

Sampled images are supported in all shader stages for image views whose format features contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT.

The image subresources for a sampled image must be in the VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_GENERAL layout in order to access its data in a shader.

13.1.4. Combined Image Sampler

A combined image sampler (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) is a single descriptor type associated with both a sampler and an image resource, combining both a sampler and sampled image descriptor into a single descriptor.

If the descriptor refers to a sampler that performs Y′C_BC_R conversion or samples a subsampled image, the sampler must only be used to sample the image in the same descriptor. Otherwise, the sampler and image in this type of descriptor can be used freely with any other samplers and images.

The image subresources for a combined image sampler must be in the VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_GENERAL layout in order to access its data in a shader.

Note

On some implementations, it may be more efficient to sample from an image using a combination of sampler and sampled image that are stored together in the descriptor set in a combined descriptor.

13.1.5. Uniform Texel Buffer

A uniform texel buffer (VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) is a descriptor type associated with a buffer resource via a buffer view that formatted load operations can be performed on.

Uniform texel buffers define a tightly-packed 1-dimensional linear array of texels, with texels going through format conversion when read in a shader in the same way as they are for an image.

Load operations from uniform texel buffers are supported in all shader stages for image formats which report support for the VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT feature bit via vkGetPhysicalDeviceFormatProperties in VkFormatProperties::bufferFeatures.

13.1.6. Storage Texel Buffer

A storage texel buffer (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) is a descriptor type associated with a buffer resource via a buffer view that formatted load, store, and atomic operations can be performed on.

Storage texel buffers define a tightly-packed 1-dimensional linear array of texels, with texels going through format conversion when read in a shader in the same way as they are for an image. Unlike uniform texel buffers, these buffers can also be written to in the same way as for storage images.

Storage texel buffer loads are supported in all shader stages for texel buffer formats which report support for the VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT feature bit via vkGetPhysicalDeviceFormatProperties in VkFormatProperties::bufferFeatures.

Stores to storage texel buffers are supported in compute shaders for texel buffer formats which report support for the VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT feature via vkGetPhysicalDeviceFormatProperties in VkFormatProperties::bufferFeatures.

Atomic operations on storage texel buffers are supported in compute shaders for texel buffer formats which report support for the VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT feature via vkGetPhysicalDeviceFormatProperties in VkFormatProperties::bufferFeatures.

When the fragmentStoresAndAtomics feature is enabled, stores and atomic operations are also supported for storage texel buffers in fragment shaders with the same set of texel buffer formats as supported in compute shaders. When the vertexPipelineStoresAndAtomics feature is enabled, stores and atomic operations are also supported in vertex, tessellation, and geometry shaders with the same set of texel buffer formats as supported in compute shaders.

13.1.7. Storage Buffer

A storage buffer (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) is a descriptor type associated with a buffer resource directly, described in a shader as a structure with various members that load, store, and atomic operations can be performed on.

Note

Atomic operations can only be performed on members of certain types as defined in the SPIR-V environment appendix.

13.1.8. Uniform Buffer

A uniform buffer (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) is a descriptor type associated with a buffer resource directly, described in a shader as a structure with various members that load operations can be performed on.

13.1.9. Dynamic Uniform Buffer

A dynamic uniform buffer (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) is almost identical to a uniform buffer, and differs only in how the offset into the buffer is specified. The base offset calculated by the VkDescriptorBufferInfo when initially updating the descriptor set is added to a dynamic offset when binding the descriptor set.

13.1.10. Dynamic Storage Buffer

A dynamic storage buffer (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC) is almost identical to a storage buffer, and differs only in how the offset into the buffer is specified. The base offset calculated by the VkDescriptorBufferInfo when initially updating the descriptor set is added to a dynamic offset when binding the descriptor set.

13.1.11. Inline Uniform Block

An inline uniform block (VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT) is almost identical to a uniform buffer, and differs only in taking its storage directly from the encompassing descriptor set instead of being backed by buffer memory. It is typically used to access a small set of constant data that does not require the additional flexibility provided by the indirection enabled when using a uniform buffer where the descriptor and the referenced buffer memory are decoupled. Compared to push constants, they allow reusing the same set of constant data across multiple disjoint sets of draw and dispatch commands.

Inline uniform block descriptors cannot be aggregated into arrays. Instead, the array size specified for an inline uniform block descriptor binding specifies the binding’s capacity in bytes.

13.1.12. Input Attachment

An input attachment (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT) is a descriptor type associated with an image resource via an image view that can be used for framebuffer local load operations in fragment shaders.

All image formats that are supported for color attachments (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) or depth/stencil attachments (VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) for a given image tiling mode are also supported for input attachments.

The image subresources for an input attachment must be in the VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_GENERAL layout in order to access its data in a shader.

13.1.13. Acceleration Structure

An acceleration structure (VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV) is a descriptor type that is used to retrieve scene geometry from within shaders bound to ray tracing pipelines. Shaders have read-only access to the memory.

13.2. Descriptor Sets

Descriptors are grouped together into descriptor set objects. A descriptor set object is an opaque object containing storage for a set of descriptors, where the types and number of descriptors is defined by a descriptor set layout. The layout object may be used to define the association of each descriptor binding with memory or other implementation resources. The layout is used both for determining the resources that need to be associated with the descriptor set, and determining the interface between shader stages and shader resources.

13.2.1. Descriptor Set Layout

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.

Descriptor set layout objects are represented by VkDescriptorSetLayout handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)

To create descriptor set layout objects, call:

VkResult vkCreateDescriptorSetLayout(
    VkDevice                                    device,
    const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkDescriptorSetLayout*                      pSetLayout);

device is the logical device that creates the descriptor set layout.
pCreateInfo is a pointer to a VkDescriptorSetLayoutCreateInfo structure specifying the state of the descriptor set layout object.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pSetLayout is a pointer to a VkDescriptorSetLayout handle in which the resulting descriptor set layout object is returned.

Valid Usage (Implicit)

VUID-vkCreateDescriptorSetLayout-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateDescriptorSetLayout-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkDescriptorSetLayoutCreateInfo structure
VUID-vkCreateDescriptorSetLayout-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateDescriptorSetLayout-pSetLayout-parameter
pSetLayout must be a valid pointer to a VkDescriptorSetLayout handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Information about the descriptor set layout is passed in a VkDescriptorSetLayoutCreateInfo structure:

typedef struct VkDescriptorSetLayoutCreateInfo {
    VkStructureType                        sType;
    const void*                            pNext;
    VkDescriptorSetLayoutCreateFlags       flags;
    uint32_t                               bindingCount;
    const VkDescriptorSetLayoutBinding*    pBindings;
} VkDescriptorSetLayoutCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkDescriptorSetLayoutCreateFlagBits specifying options for descriptor set layout creation.
bindingCount is the number of elements in pBindings.
pBindings is a pointer to an array of VkDescriptorSetLayoutBinding structures.

Valid Usage

VUID-VkDescriptorSetLayoutCreateInfo-binding-00279
The VkDescriptorSetLayoutBinding::binding members of the elements of the pBindings array must each have different values.
VUID-VkDescriptorSetLayoutCreateInfo-flags-00280
If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then all elements of pBindings must not have a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC
VUID-VkDescriptorSetLayoutCreateInfo-flags-02208
If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then all elements of pBindings must not have a descriptorType of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT
VUID-VkDescriptorSetLayoutCreateInfo-flags-00281
If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then the total number of elements of all bindings must be less than or equal to VkPhysicalDevicePushDescriptorPropertiesKHR::maxPushDescriptors
VUID-VkDescriptorSetLayoutCreateInfo-flags-03000
If any binding has the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT bit set, flags must include VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-03001
If any binding has the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT bit set, then all bindings must not have descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC

Valid Usage (Implicit)

VUID-VkDescriptorSetLayoutCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
VUID-VkDescriptorSetLayoutCreateInfo-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkDescriptorSetLayoutBindingFlagsCreateInfo
VUID-VkDescriptorSetLayoutCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkDescriptorSetLayoutCreateInfo-flags-parameter
flags must be a valid combination of VkDescriptorSetLayoutCreateFlagBits values
VUID-VkDescriptorSetLayoutCreateInfo-pBindings-parameter
If bindingCount is not 0, pBindings must be a valid pointer to an array of bindingCount valid VkDescriptorSetLayoutBinding structures

Bits which can be set in VkDescriptorSetLayoutCreateInfo::flags to specify options for descriptor set layout are:

typedef enum VkDescriptorSetLayoutCreateFlagBits {
    VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0x00000002,
    VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001,
    VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
    VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkDescriptorSetLayoutCreateFlagBits;

VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR specifies that descriptor sets must not be allocated using this layout, and descriptors are instead pushed by vkCmdPushDescriptorSetKHR.
VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT specifies that descriptor sets using this layout must be allocated from a descriptor pool created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT bit set. Descriptor set layouts created with this bit set have alternate limits for the maximum number of descriptors per-stage and per-pipeline layout. The non-UpdateAfterBind limits only count descriptors in sets created without this flag. The UpdateAfterBind limits count all descriptors, but the limits may be higher than the non-UpdateAfterBind limits.

typedef VkFlags VkDescriptorSetLayoutCreateFlags;

VkDescriptorSetLayoutCreateFlags is a bitmask type for setting a mask of zero or more VkDescriptorSetLayoutCreateFlagBits.

The VkDescriptorSetLayoutBinding structure is defined as:

typedef struct VkDescriptorSetLayoutBinding {
    uint32_t              binding;
    VkDescriptorType      descriptorType;
    uint32_t              descriptorCount;
    VkShaderStageFlags    stageFlags;
    const VkSampler*      pImmutableSamplers;
} VkDescriptorSetLayoutBinding;

binding is the binding number of this entry and corresponds to a resource of the same binding number in the shader stages.
descriptorType is a VkDescriptorType specifying which type of resource descriptors are used for this binding.
descriptorCount is the number of descriptors contained in the binding, accessed in a shader as an array , except if descriptorType is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT in which case descriptorCount is the size in bytes of the inline uniform block . If descriptorCount is zero this binding entry is reserved and the resource must not be accessed from any stage via this binding within any pipeline using the set layout.
stageFlags member is a bitmask of VkShaderStageFlagBits specifying which pipeline shader stages can access a resource for this binding. VK_SHADER_STAGE_ALL is a shorthand specifying that all defined shader stages, including any additional stages defined by extensions, can access the resource.

If a shader stage is not included in stageFlags, then a resource must not be accessed from that stage via this binding within any pipeline using the set layout. Other than input attachments which are limited to the fragment shader, there are no limitations on what combinations of stages can use a descriptor binding, and in particular a binding can be used by both graphics stages and the compute stage.
pImmutableSamplers affects initialization of samplers. If descriptorType specifies a VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER type descriptor, then pImmutableSamplers can be used to initialize a set of immutable samplers. Immutable samplers are permanently bound into the set layout and must not be changed; updating a VK_DESCRIPTOR_TYPE_SAMPLER descriptor with immutable samplers is not allowed and updates to a VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER descriptor with immutable samplers does not modify the samplers (the image views are updated, but the sampler updates are ignored). If pImmutableSamplers is not NULL, then it points to an array of sampler handles that will be copied into the set layout and used for the corresponding binding. Only the sampler handles are copied; the sampler objects must not be destroyed before the final use of the set layout and any descriptor pools and sets created using it. If pImmutableSamplers is NULL, then the sampler slots are dynamic and sampler handles must be bound into descriptor sets using this layout. If descriptorType is not one of these descriptor types, then pImmutableSamplers is ignored.

The above layout definition allows the descriptor bindings to be specified sparsely such that not all binding numbers between 0 and the maximum binding number need to be specified in the pBindings array. Bindings that are not specified have a descriptorCount and stageFlags of zero, and the value of descriptorType is undefined. However, all binding numbers between 0 and the maximum binding number in the VkDescriptorSetLayoutCreateInfo::pBindings array may consume memory in the descriptor set layout even if not all descriptor bindings are used, though it should not consume additional memory from the descriptor pool.

Note

The maximum binding number specified should be as compact as possible to avoid wasted memory.

Valid Usage

VUID-VkDescriptorSetLayoutBinding-descriptorType-00282
If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and descriptorCount is not 0 and pImmutableSamplers is not NULL, pImmutableSamplers must be a valid pointer to an array of descriptorCount valid VkSampler handles
VUID-VkDescriptorSetLayoutBinding-descriptorType-02209
If descriptorType is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then descriptorCount must be a multiple of 4
VUID-VkDescriptorSetLayoutBinding-descriptorType-02210
If descriptorType is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then descriptorCount must be less than or equal to VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxInlineUniformBlockSize
VUID-VkDescriptorSetLayoutBinding-descriptorCount-00283
If descriptorCount is not 0, stageFlags must be a valid combination of VkShaderStageFlagBits values
VUID-VkDescriptorSetLayoutBinding-descriptorType-01510
If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT and descriptorCount is not 0, then stageFlags must be 0 or VK_SHADER_STAGE_FRAGMENT_BIT

Valid Usage (Implicit)

VUID-VkDescriptorSetLayoutBinding-descriptorType-parameter
descriptorType must be a valid VkDescriptorType value

If the pNext chain of a VkDescriptorSetLayoutCreateInfo structure includes a VkDescriptorSetLayoutBindingFlagsCreateInfo structure, then that structure includes an array of flags, one for each descriptor set layout binding.

The VkDescriptorSetLayoutBindingFlagsCreateInfo structure is defined as:

typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo {
    VkStructureType                    sType;
    const void*                        pNext;
    uint32_t                           bindingCount;
    const VkDescriptorBindingFlags*    pBindingFlags;
} VkDescriptorSetLayoutBindingFlagsCreateInfo;

or the equivalent

typedef VkDescriptorSetLayoutBindingFlagsCreateInfo VkDescriptorSetLayoutBindingFlagsCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
bindingCount is zero or the number of elements in pBindingFlags.
pBindingFlags is a pointer to an array of VkDescriptorBindingFlags bitfields, one for each descriptor set layout binding.

If bindingCount is zero or if this structure is not included in the pNext chain, the VkDescriptorBindingFlags for each descriptor set layout binding is considered to be zero. Otherwise, the descriptor set layout binding at VkDescriptorSetLayoutCreateInfo::pBindings[i] uses the flags in pBindingFlags[i].

Valid Usage

VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-bindingCount-03002
If bindingCount is not zero, bindingCount must equal VkDescriptorSetLayoutCreateInfo::bindingCount
VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-flags-03003
If VkDescriptorSetLayoutCreateInfo::flags includes VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT, or VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT
VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004
If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding
VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingUniformBufferUpdateAfterBind-03005
If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingUniformBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT
VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingSampledImageUpdateAfterBind-03006
If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingSampledImageUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, or VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT
VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingStorageImageUpdateAfterBind-03007
If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingStorageImageUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT
VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingStorageBufferUpdateAfterBind-03008
If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingStorageBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT
VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingUniformTexelBufferUpdateAfterBind-03009
If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingUniformTexelBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT
VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingStorageTexelBufferUpdateAfterBind-03010
If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingStorageTexelBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT
VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingInlineUniformBlockUpdateAfterBind-02211
If VkPhysicalDeviceInlineUniformBlockFeaturesEXT::descriptorBindingInlineUniformBlockUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT
VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-None-03011
All bindings with descriptor type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT
VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingUpdateUnusedWhilePending-03012
If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingUpdateUnusedWhilePending is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT
VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingPartiallyBound-03013
If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingPartiallyBound is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT
VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingVariableDescriptorCount-03014
If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingVariableDescriptorCount is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT
VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03015
If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, that element’s descriptorType must not be VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC

Valid Usage (Implicit)

VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO
VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-parameter
If bindingCount is not 0, and pBindingFlags is not NULL, pBindingFlags must be a valid pointer to an array of bindingCount valid combinations of VkDescriptorBindingFlagBits values

Bits which can be set in each element of VkDescriptorSetLayoutBindingFlagsCreateInfo::pBindingFlags to specify options for the corresponding descriptor set layout binding are:

typedef enum VkDescriptorBindingFlagBits {
    VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 0x00000001,
    VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 0x00000002,
    VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 0x00000004,
    VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 0x00000008,
    VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
    VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT,
    VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT,
    VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT,
    VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkDescriptorBindingFlagBits;

or the equivalent

typedef VkDescriptorBindingFlagBits VkDescriptorBindingFlagBitsEXT;

VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT indicates that if descriptors in this binding are updated between when the descriptor set is bound in a command buffer and when that command buffer is submitted to a queue, then the submission will use the most recently set descriptors for this binding and the updates do not invalidate the command buffer. Descriptor bindings created with this flag are also partially exempt from the external synchronization requirement in vkUpdateDescriptorSetWithTemplateKHR and vkUpdateDescriptorSets. Multiple descriptors with this flag set can be updated concurrently in different threads, though the same descriptor must not be updated concurrently by two threads. Descriptors with this flag set can be updated concurrently with the set being bound to a command buffer in another thread, but not concurrently with the set being reset or freed.
VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT indicates that descriptors in this binding that are not dynamically used need not contain valid descriptors at the time the descriptors are consumed. A descriptor is dynamically used if any shader invocation executes an instruction that performs any memory access using the descriptor.
VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT indicates that descriptors in this binding can be updated after a command buffer has bound this descriptor set, or while a command buffer that uses this descriptor set is pending execution, as long as the descriptors that are updated are not used by those command buffers. If VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT is also set, then descriptors can be updated as long as they are not dynamically used by any shader invocations. If VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT is not set, then descriptors can be updated as long as they are not statically used by any shader invocations.
VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT indicates that this descriptor binding has a variable size that will be specified when a descriptor set is allocated using this layout. The value of descriptorCount is treated as an upper bound on the size of the binding. This must only be used for the last binding in the descriptor set layout (i.e. the binding with the largest value of binding). For the purposes of counting against limits such as maxDescriptorSet* and maxPerStageDescriptor*, the full value of descriptorCount is counted , except for descriptor bindings with a descriptor type of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT where descriptorCount specifies the upper bound on the byte size of the binding, thus it counts against the maxInlineUniformBlockSize limit instead. .

Note

Note that while VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT and VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT both involve updates to descriptor sets after they are bound, VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT is a weaker requirement since it is only about descriptors that are not used, whereas VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT requires the implementation to observe updates to descriptors that are used.

typedef VkFlags VkDescriptorBindingFlags;

or the equivalent

typedef VkDescriptorBindingFlags VkDescriptorBindingFlagsEXT;

VkDescriptorBindingFlags is a bitmask type for setting a mask of zero or more VkDescriptorBindingFlagBits.

To query information about whether a descriptor set layout can be created, call:

void vkGetDescriptorSetLayoutSupport(
    VkDevice                                    device,
    const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
    VkDescriptorSetLayoutSupport*               pSupport);

or the equivalent command

void vkGetDescriptorSetLayoutSupportKHR(
    VkDevice                                    device,
    const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
    VkDescriptorSetLayoutSupport*               pSupport);

device is the logical device that would create the descriptor set layout.
pCreateInfo is a pointer to a VkDescriptorSetLayoutCreateInfo structure specifying the state of the descriptor set layout object.
pSupport is a pointer to a VkDescriptorSetLayoutSupport structure, in which information about support for the descriptor set layout object is returned.

Some implementations have limitations on what fits in a descriptor set which are not easily expressible in terms of existing limits like maxDescriptorSet*, for example if all descriptor types share a limited space in memory but each descriptor is a different size or alignment. This command returns information about whether a descriptor set satisfies this limit. If the descriptor set layout satisfies the VkPhysicalDeviceMaintenance3Properties::maxPerSetDescriptors limit, this command is guaranteed to return VK_TRUE in VkDescriptorSetLayoutSupport::supported. If the descriptor set layout exceeds the VkPhysicalDeviceMaintenance3Properties::maxPerSetDescriptors limit, whether the descriptor set layout is supported is implementation-dependent and may depend on whether the descriptor sizes and alignments cause the layout to exceed an internal limit.

This command does not consider other limits such as maxPerStageDescriptor*, and so a descriptor set layout that is supported according to this command must still satisfy the pipeline layout limits such as maxPerStageDescriptor* in order to be used in a pipeline layout.

Note

This is a VkDevice query rather than VkPhysicalDevice because the answer may depend on enabled features.

Valid Usage (Implicit)

VUID-vkGetDescriptorSetLayoutSupport-device-parameter
device must be a valid VkDevice handle
VUID-vkGetDescriptorSetLayoutSupport-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkDescriptorSetLayoutCreateInfo structure
VUID-vkGetDescriptorSetLayoutSupport-pSupport-parameter
pSupport must be a valid pointer to a VkDescriptorSetLayoutSupport structure

Information about support for the descriptor set layout is returned in a VkDescriptorSetLayoutSupport structure:

typedef struct VkDescriptorSetLayoutSupport {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           supported;
} VkDescriptorSetLayoutSupport;

or the equivalent

typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
supported specifies whether the descriptor set layout can be created.

supported is set to VK_TRUE if the descriptor set can be created, or else is set to VK_FALSE.

Valid Usage (Implicit)

VUID-VkDescriptorSetLayoutSupport-sType-sType
sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT
VUID-VkDescriptorSetLayoutSupport-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkDescriptorSetVariableDescriptorCountLayoutSupport
VUID-VkDescriptorSetLayoutSupport-sType-unique
The sType value of each struct in the pNext chain must be unique

If the pNext chain of a VkDescriptorSetLayoutSupport structure includes a VkDescriptorSetVariableDescriptorCountLayoutSupport structure, then that structure returns additional information about whether the descriptor set layout is supported.

typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           maxVariableDescriptorCount;
} VkDescriptorSetVariableDescriptorCountLayoutSupport;

or the equivalent

typedef VkDescriptorSetVariableDescriptorCountLayoutSupport VkDescriptorSetVariableDescriptorCountLayoutSupportEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
maxVariableDescriptorCount indicates the maximum number of descriptors supported in the highest numbered binding of the layout, if that binding is variable-sized. If the highest numbered binding of the layout has a descriptor type of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then maxVariableDescriptorCount indicates the maximum byte size supported for the binding, if that binding is variable-sized.

If the create info includes a variable-sized descriptor, then supported is determined assuming the requested size of the variable-sized descriptor, and maxVariableDescriptorCount is set to the maximum size of that descriptor that can be successfully created (which is greater than or equal to the requested size passed in). If the create info does not include a variable-sized descriptor or if the VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingVariableDescriptorCount feature is not enabled, then maxVariableDescriptorCount is set to zero. For the purposes of this command, a variable-sized descriptor binding with a descriptorCount of zero is treated as if the descriptorCount is one, and thus the binding is not ignored and the maximum descriptor count will be returned. If the layout is not supported, then the value written to maxVariableDescriptorCount is undefined.

Valid Usage (Implicit)

VUID-VkDescriptorSetVariableDescriptorCountLayoutSupport-sType-sType
sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT

The following examples show a shader snippet using two descriptor sets, and application code that creates corresponding descriptor set layouts.

GLSL example

//
// binding to a single sampled image descriptor in set 0
//
layout (set=0, binding=0) uniform texture2D mySampledImage;

//
// binding to an array of sampled image descriptors in set 0
//
layout (set=0, binding=1) uniform texture2D myArrayOfSampledImages[12];

//
// binding to a single uniform buffer descriptor in set 1
//
layout (set=1, binding=0) uniform myUniformBuffer
{
    vec4 myElement[32];
};

SPIR-V example

               ...
          %1 = OpExtInstImport "GLSL.std.450"
               ...
               OpName %9 "mySampledImage"
               OpName %14 "myArrayOfSampledImages"
               OpName %18 "myUniformBuffer"
               OpMemberName %18 0 "myElement"
               OpName %20 ""
               OpDecorate %9 DescriptorSet 0
               OpDecorate %9 Binding 0
               OpDecorate %14 DescriptorSet 0
               OpDecorate %14 Binding 1
               OpDecorate %17 ArrayStride 16
               OpMemberDecorate %18 0 Offset 0
               OpDecorate %18 Block
               OpDecorate %20 DescriptorSet 1
               OpDecorate %20 Binding 0
          %2 = OpTypeVoid
          %3 = OpTypeFunction %2
          %6 = OpTypeFloat 32
          %7 = OpTypeImage %6 2D 0 0 0 1 Unknown
          %8 = OpTypePointer UniformConstant %7
          %9 = OpVariable %8 UniformConstant
         %10 = OpTypeInt 32 0
         %11 = OpConstant %10 12
         %12 = OpTypeArray %7 %11
         %13 = OpTypePointer UniformConstant %12
         %14 = OpVariable %13 UniformConstant
         %15 = OpTypeVector %6 4
         %16 = OpConstant %10 32
         %17 = OpTypeArray %15 %16
         %18 = OpTypeStruct %17
         %19 = OpTypePointer Uniform %18
         %20 = OpVariable %19 Uniform
               ...

API example

VkResult myResult;

const VkDescriptorSetLayoutBinding myDescriptorSetLayoutBinding[] =
{
    // binding to a single image descriptor
    {
        0,                                      // binding
        VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,       // descriptorType
        1,                                      // descriptorCount
        VK_SHADER_STAGE_FRAGMENT_BIT,           // stageFlags
        NULL                                    // pImmutableSamplers
    },

    // binding to an array of image descriptors
    {
        1,                                      // binding
        VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,       // descriptorType
        12,                                     // descriptorCount
        VK_SHADER_STAGE_FRAGMENT_BIT,           // stageFlags
        NULL                                    // pImmutableSamplers
    },

    // binding to a single uniform buffer descriptor
    {
        0,                                      // binding
        VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,      // descriptorType
        1,                                      // descriptorCount
        VK_SHADER_STAGE_FRAGMENT_BIT,           // stageFlags
        NULL                                    // pImmutableSamplers
    }
};

const VkDescriptorSetLayoutCreateInfo myDescriptorSetLayoutCreateInfo[] =
{
    // Create info for first descriptor set with two descriptor bindings
    {
        VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,    // sType
        NULL,                                                   // pNext
        0,                                                      // flags
        2,                                                      // bindingCount
        &myDescriptorSetLayoutBinding[0]                        // pBindings
    },

    // Create info for second descriptor set with one descriptor binding
    {
        VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,    // sType
        NULL,                                                   // pNext
        0,                                                      // flags
        1,                                                      // bindingCount
        &myDescriptorSetLayoutBinding[2]                        // pBindings
    }
};

VkDescriptorSetLayout myDescriptorSetLayout[2];

//
// Create first descriptor set layout
//
myResult = vkCreateDescriptorSetLayout(
    myDevice,
    &myDescriptorSetLayoutCreateInfo[0],
    NULL,
    &myDescriptorSetLayout[0]);

//
// Create second descriptor set layout
//
myResult = vkCreateDescriptorSetLayout(
    myDevice,
    &myDescriptorSetLayoutCreateInfo[1],
    NULL,
    &myDescriptorSetLayout[1]);

To destroy a descriptor set layout, call:

void vkDestroyDescriptorSetLayout(
    VkDevice                                    device,
    VkDescriptorSetLayout                       descriptorSetLayout,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the descriptor set layout.
descriptorSetLayout is the descriptor set layout to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00284
If VkAllocationCallbacks were provided when descriptorSetLayout was created, a compatible set of callbacks must be provided here
VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00285
If no VkAllocationCallbacks were provided when descriptorSetLayout was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyDescriptorSetLayout-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parameter
If descriptorSetLayout is not VK_NULL_HANDLE, descriptorSetLayout must be a valid VkDescriptorSetLayout handle
VUID-vkDestroyDescriptorSetLayout-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parent
If descriptorSetLayout is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to descriptorSetLayout must be externally synchronized

13.2.2. Pipeline Layouts

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 describing 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.

Pipeline layout objects are represented by VkPipelineLayout handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)

To create a pipeline layout, call:

VkResult vkCreatePipelineLayout(
    VkDevice                                    device,
    const VkPipelineLayoutCreateInfo*           pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkPipelineLayout*                           pPipelineLayout);

device is the logical device that creates the pipeline layout.
pCreateInfo is a pointer to a VkPipelineLayoutCreateInfo structure specifying the state of the pipeline layout object.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pPipelineLayout is a pointer to a VkPipelineLayout handle in which the resulting pipeline layout object is returned.

Valid Usage (Implicit)

VUID-vkCreatePipelineLayout-device-parameter
device must be a valid VkDevice handle
VUID-vkCreatePipelineLayout-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkPipelineLayoutCreateInfo structure
VUID-vkCreatePipelineLayout-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreatePipelineLayout-pPipelineLayout-parameter
pPipelineLayout must be a valid pointer to a VkPipelineLayout handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkPipelineLayoutCreateInfo structure is defined as:

typedef struct VkPipelineLayoutCreateInfo {
    VkStructureType                 sType;
    const void*                     pNext;
    VkPipelineLayoutCreateFlags     flags;
    uint32_t                        setLayoutCount;
    const VkDescriptorSetLayout*    pSetLayouts;
    uint32_t                        pushConstantRangeCount;
    const VkPushConstantRange*      pPushConstantRanges;
} VkPipelineLayoutCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
setLayoutCount is the number of descriptor sets included in the pipeline layout.
pSetLayouts is a pointer to an array of VkDescriptorSetLayout objects.
pushConstantRangeCount is the number of push constant ranges included in the pipeline layout.
pPushConstantRanges is a pointer to an array of VkPushConstantRange structures defining a set of push constant ranges for use in a single pipeline layout. In addition to descriptor set layouts, a pipeline layout also describes how many push constants can be accessed by each stage of the pipeline.

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

VUID-VkPipelineLayoutCreateInfo-setLayoutCount-00286
setLayoutCount must be less than or equal to VkPhysicalDeviceLimits::maxBoundDescriptorSets
VUID-VkPipelineLayoutCreateInfo-descriptorType-03016
The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSamplers
VUID-VkPipelineLayoutCreateInfo-descriptorType-03017
The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorUniformBuffers
VUID-VkPipelineLayoutCreateInfo-descriptorType-03018
The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageBuffers
VUID-VkPipelineLayoutCreateInfo-descriptorType-03019
The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSampledImages
VUID-VkPipelineLayoutCreateInfo-descriptorType-03020
The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageImages
VUID-VkPipelineLayoutCreateInfo-descriptorType-03021
The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorInputAttachments
VUID-VkPipelineLayoutCreateInfo-descriptorType-02214
The total number of bindings in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxPerStageDescriptorInlineUniformBlocks
VUID-VkPipelineLayoutCreateInfo-descriptorType-03022
The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxPerStageDescriptorUpdateAfterBindSamplers
VUID-VkPipelineLayoutCreateInfo-descriptorType-03023
The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxPerStageDescriptorUpdateAfterBindUniformBuffers
VUID-VkPipelineLayoutCreateInfo-descriptorType-03024
The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxPerStageDescriptorUpdateAfterBindStorageBuffers
VUID-VkPipelineLayoutCreateInfo-descriptorType-03025
The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxPerStageDescriptorUpdateAfterBindSampledImages
VUID-VkPipelineLayoutCreateInfo-descriptorType-03026
The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxPerStageDescriptorUpdateAfterBindStorageImages
VUID-VkPipelineLayoutCreateInfo-descriptorType-03027
The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxPerStageDescriptorUpdateAfterBindInputAttachments
VUID-VkPipelineLayoutCreateInfo-descriptorType-02215
The total number of bindings with a descriptorType of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks
VUID-VkPipelineLayoutCreateInfo-descriptorType-03028
The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSamplers
VUID-VkPipelineLayoutCreateInfo-descriptorType-03029
The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffers
VUID-VkPipelineLayoutCreateInfo-descriptorType-03030
The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffersDynamic
VUID-VkPipelineLayoutCreateInfo-descriptorType-03031
The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffers
VUID-VkPipelineLayoutCreateInfo-descriptorType-03032
The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffersDynamic
VUID-VkPipelineLayoutCreateInfo-descriptorType-03033
The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSampledImages
VUID-VkPipelineLayoutCreateInfo-descriptorType-03034
The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageImages
VUID-VkPipelineLayoutCreateInfo-descriptorType-03035
The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetInputAttachments
VUID-VkPipelineLayoutCreateInfo-descriptorType-02216
The total number of bindings in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxDescriptorSetInlineUniformBlocks
VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03036
The total number of descriptors of the type VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxDescriptorSetUpdateAfterBindSamplers
VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03037
The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxDescriptorSetUpdateAfterBindUniformBuffers
VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03038
The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxDescriptorSetUpdateAfterBindUniformBuffersDynamic
VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03039
The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxDescriptorSetUpdateAfterBindStorageBuffers
VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03040
The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxDescriptorSetUpdateAfterBindStorageBuffersDynamic
VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03041
The total number of descriptors of the type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxDescriptorSetUpdateAfterBindSampledImages
VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03042
The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxDescriptorSetUpdateAfterBindStorageImages
VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03043
The total number of descriptors of the type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxDescriptorSetUpdateAfterBindInputAttachments
VUID-VkPipelineLayoutCreateInfo-descriptorType-02217
The total number of bindings with a descriptorType of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxDescriptorSetUpdateAfterBindInlineUniformBlocks
VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-00292
Any two elements of pPushConstantRanges must not include the same stage in stageFlags
VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00293
pSetLayouts must not contain more than one descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR set
VUID-VkPipelineLayoutCreateInfo-descriptorType-02381
The total number of bindings with a descriptorType of VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxDescriptorSetAccelerationStructures

Valid Usage (Implicit)

VUID-VkPipelineLayoutCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
VUID-VkPipelineLayoutCreateInfo-pNext-pNext
pNext must be NULL
VUID-VkPipelineLayoutCreateInfo-flags-zerobitmask
flags must be 0
VUID-VkPipelineLayoutCreateInfo-pSetLayouts-parameter
If setLayoutCount is not 0, pSetLayouts must be a valid pointer to an array of setLayoutCount valid VkDescriptorSetLayout handles
VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-parameter
If pushConstantRangeCount is not 0, pPushConstantRanges must be a valid pointer to an array of pushConstantRangeCount valid VkPushConstantRange structures

typedef VkFlags VkPipelineLayoutCreateFlags;

VkPipelineLayoutCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

The VkPushConstantRange structure is defined as:

typedef struct VkPushConstantRange {
    VkShaderStageFlags    stageFlags;
    uint32_t              offset;
    uint32_t              size;
} VkPushConstantRange;

stageFlags is a set of stage flags describing the shader stages that will access a range of push constants. If a particular stage is not included in the range, then accessing members of that range of push constants from the corresponding shader stage will return undefined values.
offset and size are the start offset and size, respectively, consumed by the range. Both offset and size are in units of bytes and must be a multiple of 4. The layout of the push constant variables is specified in the shader.

Valid Usage

VUID-VkPushConstantRange-offset-00294
offset must be less than VkPhysicalDeviceLimits::maxPushConstantsSize
VUID-VkPushConstantRange-offset-00295
offset must be a multiple of 4
VUID-VkPushConstantRange-size-00296
size must be greater than 0
VUID-VkPushConstantRange-size-00297
size must be a multiple of 4
VUID-VkPushConstantRange-size-00298
size must be less than or equal to VkPhysicalDeviceLimits::maxPushConstantsSize minus offset

Valid Usage (Implicit)

VUID-VkPushConstantRange-stageFlags-parameter
stageFlags must be a valid combination of VkShaderStageFlagBits values
VUID-VkPushConstantRange-stageFlags-requiredbitmask
stageFlags must not be 0

Once created, pipeline layouts are used as part of pipeline creation (see Pipelines), as part of binding descriptor sets (see Descriptor Set Binding), and as part of setting push constants (see Push Constant Updates). Pipeline creation accepts a pipeline layout as input, and the layout may be used to map (set, binding, arrayElement) tuples to implementation resources or memory locations within a descriptor set. The assignment of implementation 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 Pipeline Layout Resource Limits. 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 as described in Shader Resource Limits.

Table 17. Pipeline Layout Resource Limits
Total Resources Available	Resource Types
`maxDescriptorSetSamplers` or `maxDescriptorSetUpdateAfterBindSamplers`	sampler
	combined image sampler
`maxDescriptorSetSampledImages` or `maxDescriptorSetUpdateAfterBindSampledImages`	sampled image
	combined image sampler
	uniform texel buffer
`maxDescriptorSetStorageImages` or `maxDescriptorSetUpdateAfterBindStorageImages`	storage image
	storage texel buffer
`maxDescriptorSetUniformBuffers` or `maxDescriptorSetUpdateAfterBindUniformBuffers`	uniform buffer
	uniform buffer dynamic
`maxDescriptorSetUniformBuffersDynamic` or `maxDescriptorSetUpdateAfterBindUniformBuffersDynamic`	uniform buffer dynamic
`maxDescriptorSetStorageBuffers` or `maxDescriptorSetUpdateAfterBindStorageBuffers`	storage buffer
	storage buffer dynamic
`maxDescriptorSetStorageBuffersDynamic` or `maxDescriptorSetUpdateAfterBindStorageBuffersDynamic`	storage buffer dynamic
`maxDescriptorSetInputAttachments` or `maxDescriptorSetUpdateAfterBindInputAttachments`	input attachment
`maxDescriptorSetInlineUniformBlocks` or `maxDescriptorSetUpdateAfterBindInlineUniformBlocks`	inline uniform block
`maxDescriptorSetAccelerationStructures`	acceleration structure

To destroy a pipeline layout, call:

void vkDestroyPipelineLayout(
    VkDevice                                    device,
    VkPipelineLayout                            pipelineLayout,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the pipeline layout.
pipelineLayout is the pipeline layout to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyPipelineLayout-pipelineLayout-00299
If VkAllocationCallbacks were provided when pipelineLayout was created, a compatible set of callbacks must be provided here
VUID-vkDestroyPipelineLayout-pipelineLayout-00300
If no VkAllocationCallbacks were provided when pipelineLayout was created, pAllocator must be NULL
VUID-vkDestroyPipelineLayout-pipelineLayout-02004
pipelineLayout must not have been passed to any vkCmd* command for any command buffers that are still in the recording state when vkDestroyPipelineLayout is called

Valid Usage (Implicit)

VUID-vkDestroyPipelineLayout-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyPipelineLayout-pipelineLayout-parameter
If pipelineLayout is not VK_NULL_HANDLE, pipelineLayout must be a valid VkPipelineLayout handle
VUID-vkDestroyPipelineLayout-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyPipelineLayout-pipelineLayout-parent
If pipelineLayout is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to pipelineLayout must be externally synchronized

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 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 (see Descriptor Set Binding) 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 maps pipeline resources to implementation resources, the mechanism 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 maxBoundDescriptorSets in Limits).

API example

const VkDescriptorSetLayout layouts[] = { layout1, layout2 };

const VkPushConstantRange ranges[] =
{
    {
        VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,    // stageFlags
        0,                                      // offset
        4                                       // size
    },

    {
        VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,  // stageFlags
        4,                                      // offset
        4                                       // size
    },
};

const VkPipelineLayoutCreateInfo createInfo =
{
    VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,  // sType
    NULL,                                           // pNext
    0,                                              // flags
    2,                                              // setLayoutCount
    layouts,                                        // pSetLayouts
    2,                                              // pushConstantRangeCount
    ranges                                          // pPushConstantRanges
};

VkPipelineLayout myPipelineLayout;
myResult = vkCreatePipelineLayout(
    myDevice,
    &createInfo,
    NULL,
    &myPipelineLayout);

13.2.3. Allocation of Descriptor Sets

A descriptor pool maintains a pool of descriptors, from which descriptor 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.

Descriptor pools are represented by VkDescriptorPool handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)

To create a descriptor pool object, call:

VkResult vkCreateDescriptorPool(
    VkDevice                                    device,
    const VkDescriptorPoolCreateInfo*           pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkDescriptorPool*                           pDescriptorPool);

device is the logical device that creates the descriptor pool.
pCreateInfo is a pointer to a VkDescriptorPoolCreateInfo structure specifying the state of the descriptor pool object.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pDescriptorPool is a pointer to a VkDescriptorPool handle in which the resulting descriptor pool object is returned.

pAllocator controls host memory allocation as described in the Memory Allocation chapter.

The created descriptor pool is returned in pDescriptorPool.

Valid Usage (Implicit)

VUID-vkCreateDescriptorPool-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateDescriptorPool-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkDescriptorPoolCreateInfo structure
VUID-vkCreateDescriptorPool-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateDescriptorPool-pDescriptorPool-parameter
pDescriptorPool must be a valid pointer to a VkDescriptorPool handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_FRAGMENTATION_EXT

Additional information about the pool is passed in a VkDescriptorPoolCreateInfo structure:

typedef struct VkDescriptorPoolCreateInfo {
    VkStructureType                sType;
    const void*                    pNext;
    VkDescriptorPoolCreateFlags    flags;
    uint32_t                       maxSets;
    uint32_t                       poolSizeCount;
    const VkDescriptorPoolSize*    pPoolSizes;
} VkDescriptorPoolCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkDescriptorPoolCreateFlagBits specifying certain supported operations on the pool.
maxSets is the maximum number of descriptor sets that can be allocated from the pool.
poolSizeCount is the number of elements in pPoolSizes.
pPoolSizes is a pointer to an array of VkDescriptorPoolSize structures, each containing a descriptor type and number of descriptors of that type to be allocated in the pool.

If multiple VkDescriptorPoolSize structures appear in the pPoolSizes array then the pool will be created with enough storage for the total number of descriptors of each type.

Fragmentation of a descriptor pool is possible and may lead to descriptor set allocation failures. A failure due to fragmentation is defined as failing a descriptor set allocation despite the sum of all outstanding descriptor set allocations from the pool plus the requested allocation requiring no more than the total number of descriptors requested at pool creation. Implementations provide certain guarantees of when fragmentation must not cause allocation failure, as described below.

If a descriptor pool has not had any descriptor sets freed since it was created or most recently reset then fragmentation must not cause an allocation failure (note that this is always the case for a pool created without the VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT bit set). Additionally, if all sets allocated from the pool since it was created or most recently reset use the same number of descriptors (of each type) and the requested allocation also uses that same number of descriptors (of each type), then fragmentation must not cause an allocation failure.

If an allocation failure occurs due to fragmentation, an application can create an additional descriptor pool to perform further descriptor set allocations.

If flags has the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT bit set, descriptor pool creation may fail with the error VK_ERROR_FRAGMENTATION if the total number of descriptors across all pools (including this one) created with this bit set exceeds maxUpdateAfterBindDescriptorsInAllPools, or if fragmentation of the underlying hardware resources occurs.

Valid Usage

VUID-VkDescriptorPoolCreateInfo-maxSets-00301
maxSets must be greater than 0

Valid Usage (Implicit)

VUID-VkDescriptorPoolCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
VUID-VkDescriptorPoolCreateInfo-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkDescriptorPoolInlineUniformBlockCreateInfoEXT
VUID-VkDescriptorPoolCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkDescriptorPoolCreateInfo-flags-parameter
flags must be a valid combination of VkDescriptorPoolCreateFlagBits values
VUID-VkDescriptorPoolCreateInfo-pPoolSizes-parameter
pPoolSizes must be a valid pointer to an array of poolSizeCount valid VkDescriptorPoolSize structures
VUID-VkDescriptorPoolCreateInfo-poolSizeCount-arraylength
poolSizeCount must be greater than 0

In order to be able to allocate descriptor sets having inline uniform block bindings the descriptor pool must be created with specifying the inline uniform block binding capacity of the descriptor pool, in addition to the total inline uniform data capacity in bytes which is specified through a VkDescriptorPoolSize structure with a descriptorType value of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT. This can be done by adding a VkDescriptorPoolInlineUniformBlockCreateInfoEXT structure to the pNext chain of VkDescriptorPoolCreateInfo.

The VkDescriptorPoolInlineUniformBlockCreateInfoEXT structure is defined as:

typedef struct VkDescriptorPoolInlineUniformBlockCreateInfoEXT {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           maxInlineUniformBlockBindings;
} VkDescriptorPoolInlineUniformBlockCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
maxInlineUniformBlockBindings is the number of inline uniform block bindings to allocate.

Valid Usage (Implicit)

VUID-VkDescriptorPoolInlineUniformBlockCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT

Bits which can be set in VkDescriptorPoolCreateInfo::flags to enable operations on a descriptor pool are:

typedef enum VkDescriptorPoolCreateFlagBits {
    VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
    VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0x00000002,
    VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
    VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkDescriptorPoolCreateFlagBits;

VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT specifies that descriptor sets can return their individual allocations to the pool, i.e. all of vkAllocateDescriptorSets, vkFreeDescriptorSets, and vkResetDescriptorPool are allowed. Otherwise, descriptor sets allocated from the pool must not be individually freed back to the pool, i.e. only vkAllocateDescriptorSets and vkResetDescriptorPool are allowed.
VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT specifies that descriptor sets allocated from this pool can include bindings with the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT bit set. It is valid to allocate descriptor sets that have bindings that do not set the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT bit from a pool that has VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT set.

typedef VkFlags VkDescriptorPoolCreateFlags;

VkDescriptorPoolCreateFlags is a bitmask type for setting a mask of zero or more VkDescriptorPoolCreateFlagBits.

The VkDescriptorPoolSize structure is defined as:

typedef struct VkDescriptorPoolSize {
    VkDescriptorType    type;
    uint32_t            descriptorCount;
} VkDescriptorPoolSize;

type is the type of descriptor.
descriptorCount is the number of descriptors of that type to allocate. If type is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then descriptorCount is the number of bytes to allocate for descriptors of this type.

Note

When creating a descriptor pool that will contain descriptors for combined image samplers of multi-planar formats, an application needs to account for non-trivial descriptor consumption when choosing the descriptorCount value, as indicated by VkSamplerYcbcrConversionImageFormatProperties::combinedImageSamplerDescriptorCount.

Valid Usage

VUID-VkDescriptorPoolSize-descriptorCount-00302
descriptorCount must be greater than 0
VUID-VkDescriptorPoolSize-type-02218
If type is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then descriptorCount must be a multiple of 4

Valid Usage (Implicit)

VUID-VkDescriptorPoolSize-type-parameter
type must be a valid VkDescriptorType value

To destroy a descriptor pool, call:

void vkDestroyDescriptorPool(
    VkDevice                                    device,
    VkDescriptorPool                            descriptorPool,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the descriptor pool.
descriptorPool is the descriptor pool to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

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

VUID-vkDestroyDescriptorPool-descriptorPool-00303
All submitted commands that refer to descriptorPool (via any allocated descriptor sets) must have completed execution
VUID-vkDestroyDescriptorPool-descriptorPool-00304
If VkAllocationCallbacks were provided when descriptorPool was created, a compatible set of callbacks must be provided here
VUID-vkDestroyDescriptorPool-descriptorPool-00305
If no VkAllocationCallbacks were provided when descriptorPool was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyDescriptorPool-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyDescriptorPool-descriptorPool-parameter
If descriptorPool is not VK_NULL_HANDLE, descriptorPool must be a valid VkDescriptorPool handle
VUID-vkDestroyDescriptorPool-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyDescriptorPool-descriptorPool-parent
If descriptorPool is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to descriptorPool must be externally synchronized

Descriptor sets are allocated from descriptor pool objects, and are represented by VkDescriptorSet handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)

To allocate descriptor sets from a descriptor pool, call:

VkResult vkAllocateDescriptorSets(
    VkDevice                                    device,
    const VkDescriptorSetAllocateInfo*          pAllocateInfo,
    VkDescriptorSet*                            pDescriptorSets);

device is the logical device that owns the descriptor pool.
pAllocateInfo is a pointer to a VkDescriptorSetAllocateInfo structure describing parameters of the allocation.
pDescriptorSets is a pointer to an array of VkDescriptorSet handles in which the resulting descriptor set objects are returned.

The allocated descriptor sets are returned in pDescriptorSets.

When a descriptor set is allocated, the initial state is largely uninitialized and all descriptors are undefined. Descriptors also become undefined if the underlying resource is destroyed. Descriptor sets containing undefined descriptors can still be bound and used, subject to the following conditions:

For descriptor set bindings created with the VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT bit set, all descriptors in that binding that are dynamically used must have been populated before the descriptor set is consumed.
For descriptor set bindings created without the VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT bit set, all descriptors in that binding that are statically used must have been populated before the descriptor set is consumed.
Descriptor bindings with descriptor type of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT can be undefined when the descriptor set is consumed; though values in that block will be undefined.
Entries that are not used by a pipeline can have undefined descriptors.

If a call to vkAllocateDescriptorSets would cause the total number of descriptor sets allocated from the pool to exceed the value of VkDescriptorPoolCreateInfo::maxSets used to create pAllocateInfo->descriptorPool, then the allocation may fail due to lack of space in the descriptor pool. Similarly, the allocation may fail due to lack of space if the call to vkAllocateDescriptorSets would cause the number of any given descriptor type to exceed the sum of all the descriptorCount members of each element of VkDescriptorPoolCreateInfo::pPoolSizes with a member equal to that type.

Additionally, the allocation may also fail if a call to vkAllocateDescriptorSets would cause the total number of inline uniform block bindings allocated from the pool to exceed the value of VkDescriptorPoolInlineUniformBlockCreateInfoEXT::maxInlineUniformBlockBindings used to create the descriptor pool.

If the allocation fails due to no more space in the descriptor pool, and not because of system or device memory exhaustion, then VK_ERROR_OUT_OF_POOL_MEMORY must be returned.

vkAllocateDescriptorSets can be used to create multiple descriptor sets. If the creation of any of those descriptor sets fails, then the implementation must destroy all successfully created descriptor set objects from this command, set all entries of the pDescriptorSets array to VK_NULL_HANDLE and return the error.

Valid Usage (Implicit)

VUID-vkAllocateDescriptorSets-device-parameter
device must be a valid VkDevice handle
VUID-vkAllocateDescriptorSets-pAllocateInfo-parameter
pAllocateInfo must be a valid pointer to a valid VkDescriptorSetAllocateInfo structure
VUID-vkAllocateDescriptorSets-pDescriptorSets-parameter
pDescriptorSets must be a valid pointer to an array of pAllocateInfo::descriptorSetCount VkDescriptorSet handles
VUID-vkAllocateDescriptorSets-pAllocateInfo
::descriptorSetCount-arraylength The value referenced by pAllocateInfo::descriptorSetCount must be greater than 0

Host Synchronization

Host access to pAllocateInfo::descriptorPool must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_FRAGMENTED_POOL
VK_ERROR_OUT_OF_POOL_MEMORY

The VkDescriptorSetAllocateInfo structure is defined as:

typedef struct VkDescriptorSetAllocateInfo {
    VkStructureType                 sType;
    const void*                     pNext;
    VkDescriptorPool                descriptorPool;
    uint32_t                        descriptorSetCount;
    const VkDescriptorSetLayout*    pSetLayouts;
} VkDescriptorSetAllocateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
descriptorPool is the pool which the sets will be allocated from.
descriptorSetCount determines the number of descriptor sets to be allocated from the pool.
pSetLayouts is a pointer to an array of descriptor set layouts, with each member specifying how the corresponding descriptor set is allocated.

Valid Usage

VUID-VkDescriptorSetAllocateInfo-pSetLayouts-00308
Each element of pSetLayouts must not have been created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR set
VUID-VkDescriptorSetAllocateInfo-pSetLayouts-03044
If any element of pSetLayouts was created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set, descriptorPool must have been created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT flag set

Valid Usage (Implicit)

VUID-VkDescriptorSetAllocateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO
VUID-VkDescriptorSetAllocateInfo-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkDescriptorSetVariableDescriptorCountAllocateInfo
VUID-VkDescriptorSetAllocateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkDescriptorSetAllocateInfo-descriptorPool-parameter
descriptorPool must be a valid VkDescriptorPool handle
VUID-VkDescriptorSetAllocateInfo-pSetLayouts-parameter
pSetLayouts must be a valid pointer to an array of descriptorSetCount valid VkDescriptorSetLayout handles
VUID-VkDescriptorSetAllocateInfo-descriptorSetCount-arraylength
descriptorSetCount must be greater than 0
VUID-VkDescriptorSetAllocateInfo-commonparent
Both of descriptorPool, and the elements of pSetLayouts must have been created, allocated, or retrieved from the same VkDevice

If the pNext chain of a VkDescriptorSetAllocateInfo structure includes a VkDescriptorSetVariableDescriptorCountAllocateInfo structure, then that structure includes an array of descriptor counts for variable descriptor count bindings, one for each descriptor set being allocated.

The VkDescriptorSetVariableDescriptorCountAllocateInfo structure is defined as:

typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           descriptorSetCount;
    const uint32_t*    pDescriptorCounts;
} VkDescriptorSetVariableDescriptorCountAllocateInfo;

or the equivalent

typedef VkDescriptorSetVariableDescriptorCountAllocateInfo VkDescriptorSetVariableDescriptorCountAllocateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
descriptorSetCount is zero or the number of elements in pDescriptorCounts.
pDescriptorCounts is a pointer to an array of descriptor counts, with each member specifying the number of descriptors in a variable descriptor count binding in the corresponding descriptor set being allocated.

If descriptorSetCount is zero or this structure is not included in the pNext chain, then the variable lengths are considered to be zero. Otherwise, pDescriptorCounts[i] is the number of descriptors in the variable count descriptor binding in the corresponding descriptor set layout. If the variable count descriptor binding in the corresponding descriptor set layout has a descriptor type of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then pDescriptorCounts[i] specifies the binding’s capacity in bytes. If VkDescriptorSetAllocateInfo::pSetLayouts[i] does not include a variable count descriptor binding, then pDescriptorCounts[i] is ignored.

Valid Usage

VUID-VkDescriptorSetVariableDescriptorCountAllocateInfo-descriptorSetCount-03045
If descriptorSetCount is not zero, descriptorSetCount must equal VkDescriptorSetAllocateInfo::descriptorSetCount
VUID-VkDescriptorSetVariableDescriptorCountAllocateInfo-pSetLayouts-03046
If VkDescriptorSetAllocateInfo::pSetLayouts[i] has a variable descriptor count binding, then pDescriptorCounts[i] must be less than or equal to the descriptor count specified for that binding when the descriptor set layout was created.

Valid Usage (Implicit)

VUID-VkDescriptorSetVariableDescriptorCountAllocateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO
VUID-VkDescriptorSetVariableDescriptorCountAllocateInfo-pDescriptorCounts-parameter
If descriptorSetCount is not 0, pDescriptorCounts must be a valid pointer to an array of descriptorSetCount uint32_t values

To free allocated descriptor sets, call:

VkResult vkFreeDescriptorSets(
    VkDevice                                    device,
    VkDescriptorPool                            descriptorPool,
    uint32_t                                    descriptorSetCount,
    const VkDescriptorSet*                      pDescriptorSets);

device is the logical device that owns the descriptor pool.
descriptorPool is the descriptor pool from which the descriptor sets were allocated.
descriptorSetCount is the number of elements in the pDescriptorSets array.
pDescriptorSets is a pointer to an array of handles to VkDescriptorSet objects.

After calling vkFreeDescriptorSets, all descriptor sets in pDescriptorSets are invalid.

Valid Usage

VUID-vkFreeDescriptorSets-pDescriptorSets-00309
All submitted commands that refer to any element of pDescriptorSets must have completed execution
VUID-vkFreeDescriptorSets-pDescriptorSets-00310
pDescriptorSets must be a valid pointer to an array of descriptorSetCount VkDescriptorSet handles, each element of which must either be a valid handle or VK_NULL_HANDLE
VUID-vkFreeDescriptorSets-pDescriptorSets-00311
Each valid handle in pDescriptorSets must have been allocated from descriptorPool
VUID-vkFreeDescriptorSets-descriptorPool-00312
descriptorPool must have been created with the VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT flag

Valid Usage (Implicit)

VUID-vkFreeDescriptorSets-device-parameter
device must be a valid VkDevice handle
VUID-vkFreeDescriptorSets-descriptorPool-parameter
descriptorPool must be a valid VkDescriptorPool handle
VUID-vkFreeDescriptorSets-descriptorSetCount-arraylength
descriptorSetCount must be greater than 0
VUID-vkFreeDescriptorSets-descriptorPool-parent
descriptorPool must have been created, allocated, or retrieved from device
VUID-vkFreeDescriptorSets-pDescriptorSets-parent
Each element of pDescriptorSets that is a valid handle must have been created, allocated, or retrieved from descriptorPool

Host Synchronization

Host access to descriptorPool must be externally synchronized
Host access to each member of pDescriptorSets must be externally synchronized

Return Codes

VK_SUCCESS

To return all descriptor sets allocated from a given pool to the pool, rather than freeing individual descriptor sets, call:

VkResult vkResetDescriptorPool(
    VkDevice                                    device,
    VkDescriptorPool                            descriptorPool,
    VkDescriptorPoolResetFlags                  flags);

device is the logical device that owns the descriptor pool.
descriptorPool is the descriptor pool to be reset.
flags is reserved for future use.

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

VUID-vkResetDescriptorPool-descriptorPool-00313
All uses of descriptorPool (via any allocated descriptor sets) must have completed execution

Valid Usage (Implicit)

VUID-vkResetDescriptorPool-device-parameter
device must be a valid VkDevice handle
VUID-vkResetDescriptorPool-descriptorPool-parameter
descriptorPool must be a valid VkDescriptorPool handle
VUID-vkResetDescriptorPool-flags-zerobitmask
flags must be 0
VUID-vkResetDescriptorPool-descriptorPool-parent
descriptorPool must have been created, allocated, or retrieved from device

Host Synchronization

Host access to descriptorPool must be externally synchronized
Host access to any VkDescriptorSet objects allocated from descriptorPool must be externally synchronized

Return Codes

VK_SUCCESS

typedef VkFlags VkDescriptorPoolResetFlags;

VkDescriptorPoolResetFlags is a bitmask type for setting a mask, but is currently reserved for future use.

13.2.4. Descriptor Set Updates

Once allocated, descriptor sets can be updated with a combination of write and copy operations. To update descriptor sets, call:

void vkUpdateDescriptorSets(
    VkDevice                                    device,
    uint32_t                                    descriptorWriteCount,
    const VkWriteDescriptorSet*                 pDescriptorWrites,
    uint32_t                                    descriptorCopyCount,
    const VkCopyDescriptorSet*                  pDescriptorCopies);

device is the logical device that updates the descriptor sets.
descriptorWriteCount is the number of elements in the pDescriptorWrites array.
pDescriptorWrites is a pointer to an array of VkWriteDescriptorSet structures describing the descriptor sets to write to.
descriptorCopyCount is the number of elements in the pDescriptorCopies array.
pDescriptorCopies is a pointer to an array of VkCopyDescriptorSet structures describing the descriptor sets to copy between.

The operations described by pDescriptorWrites are performed first, followed by the operations described by pDescriptorCopies. Within each array, the operations are performed in the order they appear in the array.

Each element in the pDescriptorWrites array describes an operation updating the descriptor set using descriptors for resources specified in the structure.

Each element in the pDescriptorCopies array is a VkCopyDescriptorSet structure describing an operation copying descriptors between sets.

If the dstSet member of any element of pDescriptorWrites or pDescriptorCopies is bound, accessed, or modified by any command that was recorded to a command buffer which is currently in the recording or executable state, and any of the descriptor bindings that are updated were not created with the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT or VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT bits set, that command buffer becomes invalid.

Valid Usage

VUID-vkUpdateDescriptorSets-None-03047
Descriptor bindings updated by this command which were created without the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT or VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT bits set must not be used by any command that was recorded to a command buffer which is in the pending state.

Valid Usage (Implicit)

VUID-vkUpdateDescriptorSets-device-parameter
device must be a valid VkDevice handle
VUID-vkUpdateDescriptorSets-pDescriptorWrites-parameter
If descriptorWriteCount is not 0, pDescriptorWrites must be a valid pointer to an array of descriptorWriteCount valid VkWriteDescriptorSet structures
VUID-vkUpdateDescriptorSets-pDescriptorCopies-parameter
If descriptorCopyCount is not 0, pDescriptorCopies must be a valid 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

The VkWriteDescriptorSet structure is defined as:

typedef struct VkWriteDescriptorSet {
    VkStructureType                  sType;
    const void*                      pNext;
    VkDescriptorSet                  dstSet;
    uint32_t                         dstBinding;
    uint32_t                         dstArrayElement;
    uint32_t                         descriptorCount;
    VkDescriptorType                 descriptorType;
    const VkDescriptorImageInfo*     pImageInfo;
    const VkDescriptorBufferInfo*    pBufferInfo;
    const VkBufferView*              pTexelBufferView;
} VkWriteDescriptorSet;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
dstSet is the destination descriptor set to update.
dstBinding is the descriptor binding within that set.
dstArrayElement is the starting element in that array. If the descriptor binding identified by dstSet and dstBinding has a descriptor type of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then dstArrayElement specifies the starting byte offset within the binding.
descriptorCount is the number of descriptors to update (the number of elements in pImageInfo, pBufferInfo, or pTexelBufferView , or a value matching the dataSize member of a VkWriteDescriptorSetInlineUniformBlockEXT structure in the pNext chain , or a value matching the accelerationStructureCount of a VkWriteDescriptorSetAccelerationStructureNV structure in the pNext chain ). If the descriptor binding identified by dstSet and dstBinding has a descriptor type of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then descriptorCount specifies the number of bytes to update.
descriptorType is a VkDescriptorType specifying the type of each descriptor in pImageInfo, pBufferInfo, or pTexelBufferView, as described below. It must be the same type as that specified in VkDescriptorSetLayoutBinding for dstSet at dstBinding. The type of the descriptor also controls which array the descriptors are taken from.
pImageInfo is a pointer to an array of VkDescriptorImageInfo structures or is ignored, as described below.
pBufferInfo is a pointer to an array of VkDescriptorBufferInfo structures or is ignored, as described below.
pTexelBufferView is a pointer to an array of VkBufferView handles as described in the Buffer Views section or is ignored, as described below.

Only one of pImageInfo, pBufferInfo, or pTexelBufferView members is used according to the descriptor type specified in the descriptorType member of the containing VkWriteDescriptorSet structure, or none of them in case descriptorType is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, in which case the source data for the descriptor writes is taken from the VkWriteDescriptorSetInlineUniformBlockEXT structure included in the pNext chain of VkWriteDescriptorSet, or if descriptorType is VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, in which case the source data for the descriptor writes is taken from the VkWriteDescriptorSetAccelerationStructureNV structure in the pNext chain of VkWriteDescriptorSet, as specified below.

If the dstBinding has fewer than descriptorCount array elements remaining starting from dstArrayElement, then the remainder will be used to update the subsequent binding - dstBinding+1 starting at array element zero. If a binding has a descriptorCount of zero, it is skipped. This behavior applies recursively, with the update affecting consecutive bindings as needed to update all descriptorCount descriptors.

Note

The same behavior applies to bindings with a descriptor type of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT where descriptorCount specifies the number of bytes to update while dstArrayElement specifies the starting byte offset, thus in this case if the dstBinding has a smaller byte size than the sum of dstArrayElement and descriptorCount, then the remainder will be used to update the subsequent binding - dstBinding+1 starting at offset zero. This falls out as a special case of the above rule.

Valid Usage

VUID-VkWriteDescriptorSet-dstBinding-00315
dstBinding must be less than or equal to the maximum value of binding of all VkDescriptorSetLayoutBinding structures specified when dstSet’s descriptor set layout was created
VUID-VkWriteDescriptorSet-dstBinding-00316
dstBinding must be a binding with a non-zero descriptorCount
VUID-VkWriteDescriptorSet-descriptorCount-00317
All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must have identical descriptorType and stageFlags.
VUID-VkWriteDescriptorSet-descriptorCount-00318
All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must all either use immutable samplers or must all not use immutable samplers.
VUID-VkWriteDescriptorSet-descriptorType-00319
descriptorType must match the type of dstBinding within dstSet
VUID-VkWriteDescriptorSet-dstSet-00320
dstSet must be a valid VkDescriptorSet handle
VUID-VkWriteDescriptorSet-dstArrayElement-00321
The sum of dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by dstBinding, and all applicable consecutive bindings, as described by consecutive binding updates
VUID-VkWriteDescriptorSet-descriptorType-02219
If descriptorType is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, dstArrayElement must be an integer multiple of 4
VUID-VkWriteDescriptorSet-descriptorType-02220
If descriptorType is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, descriptorCount must be an integer multiple of 4
VUID-VkWriteDescriptorSet-descriptorType-00322
If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, pImageInfo must be a valid pointer to an array of descriptorCount valid VkDescriptorImageInfo structures
VUID-VkWriteDescriptorSet-descriptorType-00323
If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, pTexelBufferView must be a valid pointer to an array of descriptorCount valid VkBufferView handles
VUID-VkWriteDescriptorSet-descriptorType-00324
If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, pBufferInfo must be a valid pointer to an array of descriptorCount valid VkDescriptorBufferInfo structures
VUID-VkWriteDescriptorSet-descriptorType-00325
If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and dstSet was not allocated with a layout that included immutable samplers for dstBinding with descriptorType, the sampler member of each element of pImageInfo must be a valid VkSampler object
VUID-VkWriteDescriptorSet-descriptorType-00326
If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView and imageLayout members of each element of pImageInfo must be a valid VkImageView and VkImageLayout, respectively
VUID-VkWriteDescriptorSet-descriptorType-02221
If descriptorType is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, the pNext chain must include a VkWriteDescriptorSetInlineUniformBlockEXT structure whose dataSize member equals descriptorCount
VUID-VkWriteDescriptorSet-descriptorType-02382
If descriptorType is VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, the pNext chain must include a VkWriteDescriptorSetAccelerationStructureNV structure whose accelerationStructureCount member equals descriptorCount
VUID-VkWriteDescriptorSet-descriptorType-01946
If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, then the imageView member of each pImageInfo element must have been created without a VkSamplerYcbcrConversionInfo structure in its pNext chain
VUID-VkWriteDescriptorSet-descriptorType-02738
If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and if any element of pImageInfo has a imageView member that was created with a VkSamplerYcbcrConversionInfo structure in its pNext chain, then dstSet must have been allocated with a layout that included immutable samplers for dstBinding, and the corresponding immutable sampler must have been created with an identically defined VkSamplerYcbcrConversionInfo object
VUID-VkWriteDescriptorSet-descriptorType-01948
If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and dstSet was allocated with a layout that included immutable samplers for dstBinding, then the imageView member of each element of pImageInfo which corresponds to an immutable sampler that enables sampler Y′C_BC_R conversion must have been created with a VkSamplerYcbcrConversionInfo structure in its pNext chain with an identically defined VkSamplerYcbcrConversionInfo to the corresponding immutable sampler
VUID-VkWriteDescriptorSet-descriptorType-01402
If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, for each descriptor that will be accessed via load or store operations the imageLayout member for corresponding elements of pImageInfo must be VK_IMAGE_LAYOUT_GENERAL
VUID-VkWriteDescriptorSet-descriptorType-00327
If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the offset member of each element of pBufferInfo must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment
VUID-VkWriteDescriptorSet-descriptorType-00328
If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the offset member of each element of pBufferInfo must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment
VUID-VkWriteDescriptorSet-descriptorType-00329
If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, and the buffer member of any element of pBufferInfo is the handle of a non-sparse buffer, then that buffer must be bound completely and contiguously to a single VkDeviceMemory object
VUID-VkWriteDescriptorSet-descriptorType-00330
If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the buffer member of each element of pBufferInfo must have been created with VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT set
VUID-VkWriteDescriptorSet-descriptorType-00331
If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the buffer member of each element of pBufferInfo must have been created with VK_BUFFER_USAGE_STORAGE_BUFFER_BIT set
VUID-VkWriteDescriptorSet-descriptorType-00332
If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the range member of each element of pBufferInfo, or the effective range if range is VK_WHOLE_SIZE, must be less than or equal to VkPhysicalDeviceLimits::maxUniformBufferRange
VUID-VkWriteDescriptorSet-descriptorType-00333
If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the range member of each element of pBufferInfo, or the effective range if range is VK_WHOLE_SIZE, must be less than or equal to VkPhysicalDeviceLimits::maxStorageBufferRange
VUID-VkWriteDescriptorSet-descriptorType-00334
If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, the VkBuffer that each element of pTexelBufferView was created from must have been created with VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT set
VUID-VkWriteDescriptorSet-descriptorType-00335
If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, the VkBuffer that each element of pTexelBufferView was created from must have been created with VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT set
VUID-VkWriteDescriptorSet-descriptorType-00336
If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must have been created with the identity swizzle
VUID-VkWriteDescriptorSet-descriptorType-00337
If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_SAMPLED_BIT set
VUID-VkWriteDescriptorSet-descriptorType-01403
If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the imageLayout member of each element of pImageInfo must be a member of the list given in Sampled Image or Combined Image Sampler, corresponding to its type
VUID-VkWriteDescriptorSet-descriptorType-00338
If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set
VUID-VkWriteDescriptorSet-descriptorType-00339
If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_STORAGE_BIT set
VUID-VkWriteDescriptorSet-descriptorCount-03048
All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must have identical VkDescriptorBindingFlagBits.
VUID-VkWriteDescriptorSet-descriptorType-02752
If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER, then dstSet must not have been allocated with a layout that included immutable samplers for dstBinding

Valid Usage (Implicit)

VUID-VkWriteDescriptorSet-sType-sType
sType must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET
VUID-VkWriteDescriptorSet-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkWriteDescriptorSetAccelerationStructureNV or VkWriteDescriptorSetInlineUniformBlockEXT
VUID-VkWriteDescriptorSet-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkWriteDescriptorSet-descriptorType-parameter
descriptorType must be a valid VkDescriptorType value
VUID-VkWriteDescriptorSet-descriptorCount-arraylength
descriptorCount must be greater than 0
VUID-VkWriteDescriptorSet-commonparent
Both of dstSet, and the elements of pTexelBufferView that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

The type of descriptors in a descriptor set is specified by VkWriteDescriptorSet::descriptorType, which must be one of the values:

typedef enum VkDescriptorType {
    VK_DESCRIPTOR_TYPE_SAMPLER = 0,
    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
    VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
    VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
    VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
    VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
    VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
    VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = 1000138000,
    VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,
    VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkDescriptorType;

VK_DESCRIPTOR_TYPE_SAMPLER specifies a sampler descriptor.
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER specifies a combined image sampler descriptor.
VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE specifies a sampled image descriptor.
VK_DESCRIPTOR_TYPE_STORAGE_IMAGE specifies a storage image descriptor.
VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER specifies a uniform texel buffer descriptor.
VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER specifies a storage texel buffer descriptor.
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER specifies a uniform buffer descriptor.
VK_DESCRIPTOR_TYPE_STORAGE_BUFFER specifies a storage buffer descriptor.
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC specifies a dynamic uniform buffer descriptor.
VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC specifies a dynamic storage buffer descriptor.
VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT specifies an input attachment descriptor.
VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT specifies an inline uniform block.

When a descriptor set is updated via elements of VkWriteDescriptorSet, members of pImageInfo, pBufferInfo and pTexelBufferView are only accessed by the implementation when they correspond to descriptor type being defined - otherwise they are ignored. The members accessed are as follows for each descriptor type:

For VK_DESCRIPTOR_TYPE_SAMPLER, only the sampler member of each element of VkWriteDescriptorSet::pImageInfo is accessed.
For VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, only the imageView and imageLayout members of each element of VkWriteDescriptorSet::pImageInfo are accessed.
For VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, all members of each element of VkWriteDescriptorSet::pImageInfo are accessed.
For VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, all members of each element of VkWriteDescriptorSet::pBufferInfo are accessed.
For VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, each element of VkWriteDescriptorSet::pTexelBufferView is accessed.

When updating descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, none of the pImageInfo, pBufferInfo, or pTexelBufferView members are accessed, instead the source data of the descriptor update operation is taken from the VkWriteDescriptorSetInlineUniformBlockEXT structure in the pNext chain of VkWriteDescriptorSet. When updating descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, none of the pImageInfo, pBufferInfo, or pTexelBufferView members are accessed, instead the source data of the descriptor update operation is taken from the VkWriteDescriptorSetAccelerationStructureNV structure in the pNext chain of VkWriteDescriptorSet.

The VkDescriptorBufferInfo structure is defined as:

typedef struct VkDescriptorBufferInfo {
    VkBuffer        buffer;
    VkDeviceSize    offset;
    VkDeviceSize    range;
} VkDescriptorBufferInfo;

buffer is the buffer resource.
offset is the offset in bytes from the start of buffer. Access to buffer memory via this descriptor uses addressing that is relative to this starting offset.
range is the size in bytes that is used for this descriptor update, or VK_WHOLE_SIZE to use the range from offset to the end of the buffer.

Note

When setting range to VK_WHOLE_SIZE, the effective range must not be larger than the maximum range for the descriptor type (maxUniformBufferRange or maxStorageBufferRange). This means that VK_WHOLE_SIZE is not typically useful in the common case where uniform buffer descriptors are suballocated from a buffer that is much larger than maxUniformBufferRange.

For VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC descriptor types, offset is the base offset from which the dynamic offset is applied and range is the static size used for all dynamic offsets.

Valid Usage

VUID-VkDescriptorBufferInfo-offset-00340
offset must be less than the size of buffer
VUID-VkDescriptorBufferInfo-range-00341
If range is not equal to VK_WHOLE_SIZE, range must be greater than 0
VUID-VkDescriptorBufferInfo-range-00342
If range is not equal to VK_WHOLE_SIZE, range must be less than or equal to the size of buffer minus offset

Valid Usage (Implicit)

VUID-VkDescriptorBufferInfo-buffer-parameter
buffer must be a valid VkBuffer handle

The VkDescriptorImageInfo structure is defined as:

typedef struct VkDescriptorImageInfo {
    VkSampler        sampler;
    VkImageView      imageView;
    VkImageLayout    imageLayout;
} VkDescriptorImageInfo;

sampler is a sampler handle, and is used in descriptor updates for types VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER if the binding being updated does not use immutable samplers.
imageView is an image view handle, and is used in descriptor updates for types VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT.
imageLayout is the layout that the image subresources accessible from imageView will be in at the time this descriptor is accessed. imageLayout is used in descriptor updates for types VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT.

Members of VkDescriptorImageInfo that are not used in an update (as described above) are ignored.

Valid Usage

VUID-VkDescriptorImageInfo-imageView-00343
imageView must not be 2D or 2D array image view created from a 3D image
VUID-VkDescriptorImageInfo-imageView-01976
If imageView is created from a depth/stencil image, the aspectMask used to create the imageView must include either VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT but not both.
VUID-VkDescriptorImageInfo-imageLayout-00344
imageLayout must match the actual VkImageLayout of each subresource accessible from imageView at the time this descriptor is accessed as defined by the image layout matching rules
VUID-VkDescriptorImageInfo-sampler-01564
If sampler is used and the VkFormat of the image is a multi-planar format, the image must have been created with VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, and the aspectMask of the imageView must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or (for three-plane formats only) VK_IMAGE_ASPECT_PLANE_2_BIT

Valid Usage (Implicit)

VUID-VkDescriptorImageInfo-commonparent
Both of imageView, and sampler that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

If the descriptorType member of VkWriteDescriptorSet is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then the data to write to the descriptor set is specified through a VkWriteDescriptorSetInlineUniformBlockEXT structure included in the pNext chain of VkWriteDescriptorSet.

The VkWriteDescriptorSetInlineUniformBlockEXT structure is defined as:

typedef struct VkWriteDescriptorSetInlineUniformBlockEXT {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           dataSize;
    const void*        pData;
} VkWriteDescriptorSetInlineUniformBlockEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
dataSize is the number of bytes of inline uniform block data pointed to by pData.
pData is a pointer to dataSize number of bytes of data to write to the inline uniform block.

Valid Usage

VUID-VkWriteDescriptorSetInlineUniformBlockEXT-dataSize-02222
dataSize must be an integer multiple of 4

Valid Usage (Implicit)

VUID-VkWriteDescriptorSetInlineUniformBlockEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT
VUID-VkWriteDescriptorSetInlineUniformBlockEXT-pData-parameter
pData must be a valid pointer to an array of dataSize bytes
VUID-VkWriteDescriptorSetInlineUniformBlockEXT-dataSize-arraylength
dataSize must be greater than 0

The VkWriteDescriptorSetAccelerationStructureNV structure is defined as:

typedef struct VkWriteDescriptorSetAccelerationStructureNV {
    VkStructureType                     sType;
    const void*                         pNext;
    uint32_t                            accelerationStructureCount;
    const VkAccelerationStructureNV*    pAccelerationStructures;
} VkWriteDescriptorSetAccelerationStructureNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
accelerationStructureCount is the number of elements in pAccelerationStructures.
pAccelerationStructures are the acceleration structures to update.

Valid Usage

VUID-VkWriteDescriptorSetAccelerationStructureNV-accelerationStructureCount-02236
accelerationStructureCount must be equal to descriptorCount in the extended structure
VUID-VkWriteDescriptorSetAccelerationStructureNV-pAccelerationStructures-02764
Each acceleration structure in pAccelerationStructures must have been created with VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV

Valid Usage (Implicit)

VUID-VkWriteDescriptorSetAccelerationStructureNV-sType-sType
sType must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV
VUID-VkWriteDescriptorSetAccelerationStructureNV-pAccelerationStructures-parameter
pAccelerationStructures must be a valid pointer to an array of accelerationStructureCount valid VkAccelerationStructureNV handles
VUID-VkWriteDescriptorSetAccelerationStructureNV-accelerationStructureCount-arraylength
accelerationStructureCount must be greater than 0

The VkCopyDescriptorSet structure is defined as:

typedef struct VkCopyDescriptorSet {
    VkStructureType    sType;
    const void*        pNext;
    VkDescriptorSet    srcSet;
    uint32_t           srcBinding;
    uint32_t           srcArrayElement;
    VkDescriptorSet    dstSet;
    uint32_t           dstBinding;
    uint32_t           dstArrayElement;
    uint32_t           descriptorCount;
} VkCopyDescriptorSet;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
srcSet, srcBinding, and srcArrayElement are the source set, binding, and array element, respectively. If the descriptor binding identified by srcSet and srcBinding has a descriptor type of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then srcArrayElement specifies the starting byte offset within the binding to copy from.
dstSet, dstBinding, and dstArrayElement are the destination set, binding, and array element, respectively. If the descriptor binding identified by dstSet and dstBinding has a descriptor type of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then dstArrayElement specifies the starting byte offset within the binding to copy to.
descriptorCount is the number of descriptors to copy from the source to destination. If descriptorCount is greater than the number of remaining array elements in the source or destination binding, those affect consecutive bindings in a manner similar to VkWriteDescriptorSet above. If the descriptor binding identified by srcSet and srcBinding has a descriptor type of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then descriptorCount specifies the number of bytes to copy and the remaining array elements in the source or destination binding refer to the remaining number of bytes in those.

Valid Usage

VUID-VkCopyDescriptorSet-srcBinding-00345
srcBinding must be a valid binding within srcSet
VUID-VkCopyDescriptorSet-srcArrayElement-00346
The sum of srcArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by srcBinding, and all applicable consecutive bindings, as described by consecutive binding updates
VUID-VkCopyDescriptorSet-dstBinding-00347
dstBinding must be a valid binding within dstSet
VUID-VkCopyDescriptorSet-dstArrayElement-00348
The sum of dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by dstBinding, and all applicable consecutive bindings, as described by consecutive binding updates
VUID-VkCopyDescriptorSet-dstBinding-02632
The type of dstBinding within dstSet must be equal to the type of srcBinding within srcSet
VUID-VkCopyDescriptorSet-srcSet-00349
If srcSet is equal to dstSet, then the source and destination ranges of descriptors must not overlap, where the ranges may include array elements from consecutive bindings as described by consecutive binding updates
VUID-VkCopyDescriptorSet-srcBinding-02223
If the descriptor type of the descriptor set binding specified by srcBinding is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, srcArrayElement must be an integer multiple of 4
VUID-VkCopyDescriptorSet-dstBinding-02224
If the descriptor type of the descriptor set binding specified by dstBinding is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, dstArrayElement must be an integer multiple of 4
VUID-VkCopyDescriptorSet-srcBinding-02225
If the descriptor type of the descriptor set binding specified by either srcBinding or dstBinding is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, descriptorCount must be an integer multiple of 4
VUID-VkCopyDescriptorSet-srcSet-01918
If srcSet’s layout was created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT flag set, then dstSet’s layout must also have been created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT flag set
VUID-VkCopyDescriptorSet-srcSet-01919
If srcSet’s layout was created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT flag set, then dstSet’s layout must also have been created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT flag set
VUID-VkCopyDescriptorSet-srcSet-01920
If the descriptor pool from which srcSet was allocated was created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT flag set, then the descriptor pool from which dstSet was allocated must also have been created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT flag set
VUID-VkCopyDescriptorSet-srcSet-01921
If the descriptor pool from which srcSet was allocated was created without the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT flag set, then the descriptor pool from which dstSet was allocated must also have been created without the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT flag set
VUID-VkCopyDescriptorSet-dstBinding-02753
If the descriptor type of the descriptor set binding specified by dstBinding is VK_DESCRIPTOR_TYPE_SAMPLER, then dstSet must not have been allocated with a layout that included immutable samplers for dstBinding

Valid Usage (Implicit)

VUID-VkCopyDescriptorSet-sType-sType
sType must be VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET
VUID-VkCopyDescriptorSet-pNext-pNext
pNext must be NULL
VUID-VkCopyDescriptorSet-srcSet-parameter
srcSet must be a valid VkDescriptorSet handle
VUID-VkCopyDescriptorSet-dstSet-parameter
dstSet must be a valid VkDescriptorSet handle
VUID-VkCopyDescriptorSet-commonparent
Both of dstSet, and srcSet must have been created, allocated, or retrieved from the same VkDevice

13.2.5. Descriptor Update Templates

A descriptor update template specifies a mapping from descriptor update information in host memory to descriptors in a descriptor set. It is designed to avoid passing redundant information to the driver when frequently updating the same set of descriptors in descriptor sets.

Descriptor update template objects are represented by VkDescriptorUpdateTemplate handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate)

or the equivalent

typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR;

13.2.6. Descriptor Set Updates with Templates

Updating a large VkDescriptorSet array can be an expensive operation since an application must specify one VkWriteDescriptorSet structure for each descriptor or descriptor array to update, each of which re-specifies the same state when updating the same descriptor in multiple descriptor sets. For cases when an application wishes to update the same set of descriptors in multiple descriptor sets allocated using the same VkDescriptorSetLayout, vkUpdateDescriptorSetWithTemplate can be used as a replacement for vkUpdateDescriptorSets.

VkDescriptorUpdateTemplate allows implementations to convert a set of descriptor update operations on a single descriptor set to an internal format that, in conjunction with vkUpdateDescriptorSetWithTemplate or vkCmdPushDescriptorSetWithTemplateKHR , can be more efficient compared to calling vkUpdateDescriptorSets or vkCmdPushDescriptorSetKHR . The descriptors themselves are not specified in the VkDescriptorUpdateTemplate, rather, offsets into an application provided pointer to host memory are specified, which are combined with a pointer passed to vkUpdateDescriptorSetWithTemplate or vkCmdPushDescriptorSetWithTemplateKHR . This allows large batches of updates to be executed without having to convert application data structures into a strictly-defined Vulkan data structure.

To create a descriptor update template, call:

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

or the equivalent command

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

device is the logical device that creates the descriptor update template.
pCreateInfo is a pointer to a VkDescriptorUpdateTemplateCreateInfo structure specifying the set of descriptors to update with a single call to vkCmdPushDescriptorSetWithTemplateKHR or vkUpdateDescriptorSetWithTemplate.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pDescriptorUpdateTemplate is a pointer to a VkDescriptorUpdateTemplate handle in which the resulting descriptor update template object is returned.

Valid Usage (Implicit)

VUID-vkCreateDescriptorUpdateTemplate-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateDescriptorUpdateTemplate-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkDescriptorUpdateTemplateCreateInfo structure
VUID-vkCreateDescriptorUpdateTemplate-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateDescriptorUpdateTemplate-pDescriptorUpdateTemplate-parameter
pDescriptorUpdateTemplate must be a valid pointer to a VkDescriptorUpdateTemplate handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkDescriptorUpdateTemplateCreateInfo structure is defined as:

typedef struct VkDescriptorUpdateTemplateCreateInfo {
    VkStructureType                           sType;
    const void*                               pNext;
    VkDescriptorUpdateTemplateCreateFlags     flags;
    uint32_t                                  descriptorUpdateEntryCount;
    const VkDescriptorUpdateTemplateEntry*    pDescriptorUpdateEntries;
    VkDescriptorUpdateTemplateType            templateType;
    VkDescriptorSetLayout                     descriptorSetLayout;
    VkPipelineBindPoint                       pipelineBindPoint;
    VkPipelineLayout                          pipelineLayout;
    uint32_t                                  set;
} VkDescriptorUpdateTemplateCreateInfo;

or the equivalent

typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
descriptorUpdateEntryCount is the number of elements in the pDescriptorUpdateEntries array.
pDescriptorUpdateEntries is a pointer to an array of VkDescriptorUpdateTemplateEntry structures describing the descriptors to be updated by the descriptor update template.
templateType Specifies the type of the descriptor update template. If set to VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET it can only be used to update descriptor sets with a fixed descriptorSetLayout. If set to VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR it can only be used to push descriptor sets using the provided pipelineBindPoint, pipelineLayout, and set number.
descriptorSetLayout is the descriptor set layout the parameter update template will be used with. All descriptor sets which are going to be updated through the newly created descriptor update template must be created with this layout. descriptorSetLayout is the descriptor set layout used to build the descriptor update template. All descriptor sets which are going to be updated through the newly created descriptor update template must be created with a layout that matches (is the same as, or defined identically to) this layout. This parameter is ignored if templateType is not VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET.
pipelineBindPoint is a VkPipelineBindPoint indicating whether the descriptors will be used by graphics pipelines or compute pipelines. This parameter is ignored if templateType is not VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR
pipelineLayout is a VkPipelineLayout object used to program the bindings. This parameter is ignored if templateType is not VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR
set is the set number of the descriptor set in the pipeline layout that will be updated. This parameter is ignored if templateType is not VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR

Valid Usage

VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00350
If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, descriptorSetLayout must be a valid VkDescriptorSetLayout handle
VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00351
If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, pipelineBindPoint must be a valid VkPipelineBindPoint value
VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00352
If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, pipelineLayout must be a valid VkPipelineLayout handle
VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00353
If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR

Valid Usage (Implicit)

VUID-VkDescriptorUpdateTemplateCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO
VUID-VkDescriptorUpdateTemplateCreateInfo-pNext-pNext
pNext must be NULL
VUID-VkDescriptorUpdateTemplateCreateInfo-flags-zerobitmask
flags must be 0
VUID-VkDescriptorUpdateTemplateCreateInfo-pDescriptorUpdateEntries-parameter
pDescriptorUpdateEntries must be a valid pointer to an array of descriptorUpdateEntryCount valid VkDescriptorUpdateTemplateEntry structures
VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-parameter
templateType must be a valid VkDescriptorUpdateTemplateType value
VUID-VkDescriptorUpdateTemplateCreateInfo-descriptorUpdateEntryCount-arraylength
descriptorUpdateEntryCount must be greater than 0
VUID-VkDescriptorUpdateTemplateCreateInfo-commonparent
Both of descriptorSetLayout, and pipelineLayout that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

typedef VkFlags VkDescriptorUpdateTemplateCreateFlags;

or the equivalent

typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR;

VkDescriptorUpdateTemplateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

The descriptor update template type is determined by the VkDescriptorUpdateTemplateCreateInfo::templateType property, which takes the following values:

typedef enum VkDescriptorUpdateTemplateType {
    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0,
    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkDescriptorUpdateTemplateType;

or the equivalent

typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR;

VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET specifies that the descriptor update template will be used for descriptor set updates only.
VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR specifies that the descriptor update template will be used for push descriptor updates only.

The VkDescriptorUpdateTemplateEntry structure is defined as:

typedef struct VkDescriptorUpdateTemplateEntry {
    uint32_t            dstBinding;
    uint32_t            dstArrayElement;
    uint32_t            descriptorCount;
    VkDescriptorType    descriptorType;
    size_t              offset;
    size_t              stride;
} VkDescriptorUpdateTemplateEntry;

or the equivalent

typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR;

dstBinding is the descriptor binding to update when using this descriptor update template.
dstArrayElement is the starting element in the array belonging to dstBinding. If the descriptor binding identified by srcBinding has a descriptor type of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then dstArrayElement specifies the starting byte offset to update.
descriptorCount is the number of descriptors to update. If descriptorCount is greater than the number of remaining array elements in the destination binding, those affect consecutive bindings in a manner similar to VkWriteDescriptorSet above. If the descriptor binding identified by dstBinding has a descriptor type of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then descriptorCount specifies the number of bytes to update and the remaining array elements in the destination binding refer to the remaining number of bytes in it.
descriptorType is a VkDescriptorType specifying the type of the descriptor.
offset is the offset in bytes of the first binding in the raw data structure.
stride is the stride in bytes between two consecutive array elements of the descriptor update informations in the raw data structure. The actual pointer ptr for each array element j of update entry i is computed using the following formula:
```
    const char *ptr = (const char *)pData + pDescriptorUpdateEntries[i].offset + j * pDescriptorUpdateEntries[i].stride
```
The stride is useful in case the bindings are stored in structs along with other data. If descriptorType is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then the value of stride is ignored and the stride is assumed to be 1, i.e. the descriptor update information for them is always specified as a contiguous range.

Valid Usage

VUID-VkDescriptorUpdateTemplateEntry-dstBinding-00354
dstBinding must be a valid binding in the descriptor set layout implicitly specified when using a descriptor update template to update descriptors.
VUID-VkDescriptorUpdateTemplateEntry-dstArrayElement-00355
dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding implicitly specified when using a descriptor update template to update descriptors, and all applicable consecutive bindings, as described by consecutive binding updates
VUID-VkDescriptorUpdateTemplateEntry-descriptor-02226
If descriptor type is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, dstArrayElement must be an integer multiple of 4
VUID-VkDescriptorUpdateTemplateEntry-descriptor-02227
If descriptor type is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, descriptorCount must be an integer multiple of 4

Valid Usage (Implicit)

VUID-VkDescriptorUpdateTemplateEntry-descriptorType-parameter
descriptorType must be a valid VkDescriptorType value

To destroy a descriptor update template, call:

void vkDestroyDescriptorUpdateTemplate(
    VkDevice                                    device,
    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
    const VkAllocationCallbacks*                pAllocator);

or the equivalent command

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

device is the logical device that has been used to create the descriptor update template
descriptorUpdateTemplate is the descriptor update template to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00356
If VkAllocationCallbacks were provided when descriptorSetLayout was created, a compatible set of callbacks must be provided here
VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00357
If no VkAllocationCallbacks were provided when descriptorSetLayout was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyDescriptorUpdateTemplate-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parameter
If descriptorUpdateTemplate is not VK_NULL_HANDLE, descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle
VUID-vkDestroyDescriptorUpdateTemplate-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parent
If descriptorUpdateTemplate is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to descriptorUpdateTemplate must be externally synchronized

Once a VkDescriptorUpdateTemplate has been created, descriptor sets can be updated by calling:

void vkUpdateDescriptorSetWithTemplate(
    VkDevice                                    device,
    VkDescriptorSet                             descriptorSet,
    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
    const void*                                 pData);

or the equivalent command

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

device is the logical device that updates the descriptor sets.
descriptorSet is the descriptor set to update
descriptorUpdateTemplate is a VkDescriptorUpdateTemplate object specifying the update mapping between pData and the descriptor set to update.
pData is a pointer to memory containing one or more VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView structures used to write the descriptors.

Valid Usage

VUID-vkUpdateDescriptorSetWithTemplate-pData-01685
pData must be a valid pointer to a memory containing one or more valid instances of VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView in a layout defined by descriptorUpdateTemplate when it was created with vkCreateDescriptorUpdateTemplate

Valid Usage (Implicit)

VUID-vkUpdateDescriptorSetWithTemplate-device-parameter
device must be a valid VkDevice handle
VUID-vkUpdateDescriptorSetWithTemplate-descriptorSet-parameter
descriptorSet must be a valid VkDescriptorSet handle
VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parameter
descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle
VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parent
descriptorUpdateTemplate must have been created, allocated, or retrieved from device

Host Synchronization

Host access to descriptorSet must be externally synchronized

API example

struct AppBufferView {
    VkBufferView bufferView;
    uint32_t     applicationRelatedInformation;
};

struct AppDataStructure
{
    VkDescriptorImageInfo  imageInfo;          // a single image info
    VkDescriptorBufferInfo bufferInfoArray[3]; // 3 buffer infos in an array
    AppBufferView          bufferView[2];      // An application defined structure containing a bufferView
    // ... some more application related data
};

const VkDescriptorUpdateTemplateEntry descriptorUpdateTemplateEntries[] =
{
    // binding to a single image descriptor
    {
        0,                                           // binding
        0,                                           // dstArrayElement
        1,                                           // descriptorCount
        VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,   // descriptorType
        offsetof(AppDataStructure, imageInfo),       // offset
        0                                            // stride is not required if descriptorCount is 1
    },

    // binding to an array of buffer descriptors
    {
        1,                                           // binding
        0,                                           // dstArrayElement
        3,                                           // descriptorCount
        VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,           // descriptorType
        offsetof(AppDataStructure, bufferInfoArray), // offset
        sizeof(VkDescriptorBufferInfo)               // stride, descriptor buffer infos are compact
    },

    // binding to an array of buffer views
    {
        2,                                           // binding
        0,                                           // dstArrayElement
        2,                                           // descriptorCount
        VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,     // descriptorType
        offsetof(AppDataStructure, bufferView) +
          offsetof(AppBufferView, bufferView),       // offset
        sizeof(AppBufferView)                        // stride, bufferViews do not have to be compact
    },
};

// create a descriptor update template for descriptor set updates
const VkDescriptorUpdateTemplateCreateInfo createInfo =
{
    VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,  // sType
    NULL,                                                      // pNext
    0,                                                         // flags
    3,                                                         // descriptorUpdateEntryCount
    descriptorUpdateTemplateEntries,                           // pDescriptorUpdateEntries
    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,         // templateType
    myLayout,                                                  // descriptorSetLayout
    0,                                                         // pipelineBindPoint, ignored by given templateType
    0,                                                         // pipelineLayout, ignored by given templateType
    0,                                                         // set, ignored by given templateType
};

VkDescriptorUpdateTemplate myDescriptorUpdateTemplate;
myResult = vkCreateDescriptorUpdateTemplate(
    myDevice,
    &createInfo,
    NULL,
    &myDescriptorUpdateTemplate);
}


AppDataStructure appData;

// fill appData here or cache it in your engine
vkUpdateDescriptorSetWithTemplate(myDevice, myDescriptorSet, myDescriptorUpdateTemplate, &appData);

13.2.7. Descriptor Set Binding

To bind one or more descriptor sets to a command buffer, call:

void vkCmdBindDescriptorSets(
    VkCommandBuffer                             commandBuffer,
    VkPipelineBindPoint                         pipelineBindPoint,
    VkPipelineLayout                            layout,
    uint32_t                                    firstSet,
    uint32_t                                    descriptorSetCount,
    const VkDescriptorSet*                      pDescriptorSets,
    uint32_t                                    dynamicOffsetCount,
    const uint32_t*                             pDynamicOffsets);

commandBuffer is the command buffer that the descriptor sets will be bound to.
pipelineBindPoint is 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.
layout is a VkPipelineLayout object used to program the bindings.
firstSet is the set number of the first descriptor set to be bound.
descriptorSetCount is the number of elements in the pDescriptorSets array.
pDescriptorSets is a pointer to an array of handles to VkDescriptorSet objects describing the descriptor sets to write to.
dynamicOffsetCount is the number of dynamic offsets in the pDynamicOffsets array.
pDynamicOffsets is a pointer to an array of uint32_t values specifying dynamic offsets.

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 as described in Pipeline Layout Compatibility.

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 descriptor 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 range 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, as defined in the Pipeline Layout Compatibility section.

The descriptor set contents bound by a call to vkCmdBindDescriptorSets may be consumed at the following times:

For descriptor bindings created with the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT bit set, the contents may be consumed when the command buffer is submitted to a queue, or during shader execution of the resulting draws and dispatches, or any time in between. Otherwise,
during host execution of the command, or during shader execution of the resulting draws and dispatches, or any time in between.

Thus, the contents of a descriptor set binding must not be altered (overwritten by an update command, or freed) between the first point in time that it may be consumed, 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

VUID-vkCmdBindDescriptorSets-pDescriptorSets-00358
Each element of pDescriptorSets must have been allocated with a VkDescriptorSetLayout that matches (is the same as, or identically defined as) the VkDescriptorSetLayout at set n in layout, where n is the sum of firstSet and the index into pDescriptorSets
VUID-vkCmdBindDescriptorSets-dynamicOffsetCount-00359
dynamicOffsetCount must be equal to the total number of dynamic descriptors in pDescriptorSets
VUID-vkCmdBindDescriptorSets-firstSet-00360
The sum of firstSet and descriptorSetCount must be less than or equal to VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created
VUID-vkCmdBindDescriptorSets-pipelineBindPoint-00361
pipelineBindPoint must be supported by the commandBuffer’s parent VkCommandPool’s queue family
VUID-vkCmdBindDescriptorSets-pDynamicOffsets-01971
Each element of pDynamicOffsets which corresponds to a descriptor binding with type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment
VUID-vkCmdBindDescriptorSets-pDynamicOffsets-01972
Each element of pDynamicOffsets which corresponds to a descriptor binding with type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment
VUID-vkCmdBindDescriptorSets-pDescriptorSets-01979
For each dynamic uniform or storage buffer binding in pDescriptorSets, the sum of the effective offset, as defined above, and the range of the binding must be less than or equal to the size of the buffer

Valid Usage (Implicit)

VUID-vkCmdBindDescriptorSets-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdBindDescriptorSets-pipelineBindPoint-parameter
pipelineBindPoint must be a valid VkPipelineBindPoint value
VUID-vkCmdBindDescriptorSets-layout-parameter
layout must be a valid VkPipelineLayout handle
VUID-vkCmdBindDescriptorSets-pDescriptorSets-parameter
pDescriptorSets must be a valid pointer to an array of descriptorSetCount valid VkDescriptorSet handles
VUID-vkCmdBindDescriptorSets-pDynamicOffsets-parameter
If dynamicOffsetCount is not 0, pDynamicOffsets must be a valid pointer to an array of dynamicOffsetCount uint32_t values
VUID-vkCmdBindDescriptorSets-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdBindDescriptorSets-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
VUID-vkCmdBindDescriptorSets-descriptorSetCount-arraylength
descriptorSetCount must be greater than 0
VUID-vkCmdBindDescriptorSets-commonparent
Each of commandBuffer, layout, and the elements of pDescriptorSets must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

13.2.8. Push Descriptor Updates

In addition to allocating descriptor sets and binding them to a command buffer, an application can record descriptor updates into the command buffer.

To push descriptor updates into a command buffer, call:

void vkCmdPushDescriptorSetKHR(
    VkCommandBuffer                             commandBuffer,
    VkPipelineBindPoint                         pipelineBindPoint,
    VkPipelineLayout                            layout,
    uint32_t                                    set,
    uint32_t                                    descriptorWriteCount,
    const VkWriteDescriptorSet*                 pDescriptorWrites);

commandBuffer is the command buffer that the descriptors will be recorded in.
pipelineBindPoint is a VkPipelineBindPoint indicating whether the descriptors will be used by graphics pipelines or compute pipelines. There is a separate set of push descriptor bindings for each of graphics and compute, so binding one does not disturb the other.
layout is a VkPipelineLayout object used to program the bindings.
set is the set number of the descriptor set in the pipeline layout that will be updated.
descriptorWriteCount is the number of elements in the pDescriptorWrites array.
pDescriptorWrites is a pointer to an array of VkWriteDescriptorSet structures describing the descriptors to be updated.

Push descriptors are a small bank of descriptors whose storage is internally managed by the command buffer rather than being written into a descriptor set and later bound to a command buffer. Push descriptors allow for incremental updates of descriptors without managing the lifetime of descriptor sets.

When a command buffer begins recording, all push descriptors are undefined. Push descriptors can be updated incrementally and cause shaders to use the updated descriptors for subsequent rendering commands (either compute or graphics, according to the pipelineBindPoint) until the descriptor is overwritten, or else until the set is disturbed as described in Pipeline Layout Compatibility. When the set is disturbed or push descriptors with a different descriptor set layout are set, all push descriptors are undefined.

Push descriptors that are statically used by a pipeline must not be undefined at the time that a draw or dispatch command is recorded to execute using that pipeline. This includes immutable sampler descriptors, which must be pushed before they are accessed by a pipeline (the immutable samplers are pushed, rather than the samplers in pDescriptorWrites). Push descriptors that are not statically used can remain undefined.

Push descriptors do not use dynamic offsets. Instead, the corresponding non-dynamic descriptor types can be used and the offset member of VkDescriptorBufferInfo can be changed each time the descriptor is written.

Each element of pDescriptorWrites is interpreted as in VkWriteDescriptorSet, except the dstSet member is ignored.

To push an immutable sampler, use a VkWriteDescriptorSet with dstBinding and dstArrayElement selecting the immutable sampler’s binding. If the descriptor type is VK_DESCRIPTOR_TYPE_SAMPLER, the pImageInfo parameter is ignored and the immutable sampler is taken from the push descriptor set layout in the pipeline layout. If the descriptor type is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the sampler member of the pImageInfo parameter is ignored and the immutable sampler is taken from the push descriptor set layout in the pipeline layout.

Valid Usage

VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-00363
pipelineBindPoint must be supported by the commandBuffer’s parent VkCommandPool’s queue family
VUID-vkCmdPushDescriptorSetKHR-set-00364
set must be less than VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created
VUID-vkCmdPushDescriptorSetKHR-set-00365
set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR

Valid Usage (Implicit)

VUID-vkCmdPushDescriptorSetKHR-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-parameter
pipelineBindPoint must be a valid VkPipelineBindPoint value
VUID-vkCmdPushDescriptorSetKHR-layout-parameter
layout must be a valid VkPipelineLayout handle
VUID-vkCmdPushDescriptorSetKHR-pDescriptorWrites-parameter
pDescriptorWrites must be a valid pointer to an array of descriptorWriteCount valid VkWriteDescriptorSet structures
VUID-vkCmdPushDescriptorSetKHR-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdPushDescriptorSetKHR-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
VUID-vkCmdPushDescriptorSetKHR-descriptorWriteCount-arraylength
descriptorWriteCount must be greater than 0
VUID-vkCmdPushDescriptorSetKHR-commonparent
Both of commandBuffer, and layout must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

13.2.9. Push Descriptor Updates with Descriptor Update Templates

It is also possible to use a descriptor update template to specify the push descriptors to update. To do so, call:

void vkCmdPushDescriptorSetWithTemplateKHR(
    VkCommandBuffer                             commandBuffer,
    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
    VkPipelineLayout                            layout,
    uint32_t                                    set,
    const void*                                 pData);

commandBuffer is the command buffer that the descriptors will be recorded in.
descriptorUpdateTemplate is a descriptor update template defining how to interpret the descriptor information in pData.
layout is a VkPipelineLayout object used to program the bindings. It must be compatible with the layout used to create the descriptorUpdateTemplate handle.
set is the set number of the descriptor set in the pipeline layout that will be updated. This must be the same number used to create the descriptorUpdateTemplate handle.
pData is a pointer to memory containing descriptors for the templated update.

Valid Usage

VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-00366
The pipelineBindPoint specified during the creation of the descriptor update template must be supported by the commandBuffer’s parent VkCommandPool’s queue family
VUID-vkCmdPushDescriptorSetWithTemplateKHR-pData-01686
pData must be a valid pointer to a memory containing one or more valid instances of VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView in a layout defined by descriptorUpdateTemplate when it was created with vkCreateDescriptorUpdateTemplateKHR

Valid Usage (Implicit)

VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdPushDescriptorSetWithTemplateKHR-descriptorUpdateTemplate-parameter
descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle
VUID-vkCmdPushDescriptorSetWithTemplateKHR-layout-parameter
layout must be a valid VkPipelineLayout handle
VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
VUID-vkCmdPushDescriptorSetWithTemplateKHR-commonparent
Each of commandBuffer, descriptorUpdateTemplate, and layout must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

API example

struct AppDataStructure
{
    VkDescriptorImageInfo  imageInfo;          // a single image info
    // ... some more application related data
};

const VkDescriptorUpdateTemplateEntry descriptorUpdateTemplateEntries[] =
{
    // binding to a single image descriptor
    {
        0,                                           // binding
        0,                                           // dstArrayElement
        1,                                           // descriptorCount
        VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,   // descriptorType
        offsetof(AppDataStructure, imageInfo),       // offset
        0                                            // stride is not required if descriptorCount is 1
    }
};

// create a descriptor update template for descriptor set updates
const VkDescriptorUpdateTemplateCreateInfo createInfo =
{
    VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,  // sType
    NULL,                                                      // pNext
    0,                                                         // flags
    1,                                                         // descriptorUpdateEntryCount
    descriptorUpdateTemplateEntries,                           // pDescriptorUpdateEntries
    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR,   // templateType
    0,                                                         // descriptorSetLayout, ignored by given templateType
    VK_PIPELINE_BIND_POINT_GRAPHICS,                           // pipelineBindPoint
    myPipelineLayout,                                          // pipelineLayout
    0,                                                         // set
};

VkDescriptorUpdateTemplate myDescriptorUpdateTemplate;
myResult = vkCreateDescriptorUpdateTemplate(
    myDevice,
    &createInfo,
    NULL,
    &myDescriptorUpdateTemplate);
}

AppDataStructure appData;
// fill appData here or cache it in your engine
vkCmdPushDescriptorSetWithTemplateKHR(myCmdBuffer, myDescriptorUpdateTemplate, myPipelineLayout, 0,&appData);

13.2.10. Push Constant Updates

As described above in section Pipeline Layouts, 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.

The values of push constants are undefined at the start of a command buffer.

To update push constants, call:

void vkCmdPushConstants(
    VkCommandBuffer                             commandBuffer,
    VkPipelineLayout                            layout,
    VkShaderStageFlags                          stageFlags,
    uint32_t                                    offset,
    uint32_t                                    size,
    const void*                                 pValues);

commandBuffer is the command buffer in which the push constant update will be recorded.
layout is the pipeline layout used to program the push constant updates.
stageFlags is a bitmask of VkShaderStageFlagBits specifying the shader stages that will use the push constants in the updated range.
offset is the start offset of the push constant range to update, in units of bytes.
size is the size of the push constant range to update, in units of bytes.
pValues is a pointer to an array of size bytes containing the new push constant values.

Note

As stageFlags needs to include all flags the relevant push constant ranges were created with, any flags that are not supported by the queue family that the VkCommandPool used to allocate commandBuffer was created on are ignored.

Valid Usage

VUID-vkCmdPushConstants-offset-01795
For each byte in the range specified by offset and size and for each shader stage in stageFlags, there must be a push constant range in layout that includes that byte and that stage
VUID-vkCmdPushConstants-offset-01796
For each byte in the range specified by offset and size and for each push constant range that overlaps that byte, stageFlags must include all stages in that push constant range’s VkPushConstantRange::stageFlags
VUID-vkCmdPushConstants-offset-00368
offset must be a multiple of 4
VUID-vkCmdPushConstants-size-00369
size must be a multiple of 4
VUID-vkCmdPushConstants-offset-00370
offset must be less than VkPhysicalDeviceLimits::maxPushConstantsSize
VUID-vkCmdPushConstants-size-00371
size must be less than or equal to VkPhysicalDeviceLimits::maxPushConstantsSize minus offset

Valid Usage (Implicit)

VUID-vkCmdPushConstants-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdPushConstants-layout-parameter
layout must be a valid VkPipelineLayout handle
VUID-vkCmdPushConstants-stageFlags-parameter
stageFlags must be a valid combination of VkShaderStageFlagBits values
VUID-vkCmdPushConstants-stageFlags-requiredbitmask
stageFlags must not be 0
VUID-vkCmdPushConstants-pValues-parameter
pValues must be a valid pointer to an array of size bytes
VUID-vkCmdPushConstants-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdPushConstants-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
VUID-vkCmdPushConstants-size-arraylength
size must be greater than 0
VUID-vkCmdPushConstants-commonparent
Both of commandBuffer, and layout must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

13.3. Physical Storage Buffer Access

To query a 64-bit buffer device address value through which buffer memory can be accessed in a shader, call:

VkDeviceAddress vkGetBufferDeviceAddress(
    VkDevice                                    device,
    const VkBufferDeviceAddressInfo*            pInfo);

or the equivalent command

VkDeviceAddress vkGetBufferDeviceAddressKHR(
    VkDevice                                    device,
    const VkBufferDeviceAddressInfo*            pInfo);

or the equivalent command

VkDeviceAddress vkGetBufferDeviceAddressEXT(
    VkDevice                                    device,
    const VkBufferDeviceAddressInfo*            pInfo);

device is the logical device that the buffer was created on.
pInfo is a pointer to a VkBufferDeviceAddressInfo structure specifying the buffer to retrieve an address for.

The 64-bit return value is an address of the start of pInfo->buffer. The address range starting at this value and whose size is the size of the buffer can be used in a shader to access the memory bound to that buffer, using the SPV_KHR_physical_storage_buffer extension or the equivalent SPV_EXT_physical_storage_buffer extension and the PhysicalStorageBuffer storage class. For example, this value can be stored in a uniform buffer, and the shader can read the value from the uniform buffer and use it to do a dependent read/write to this buffer. A value of zero is reserved as a “null” pointer and must not be returned as a valid buffer device address. All loads, stores, and atomics in a shader through PhysicalStorageBuffer pointers must access addresses in the address range of some buffer.

If the buffer was created with a non-zero value of VkBufferOpaqueCaptureAddressCreateInfo::opaqueCaptureAddress or VkBufferDeviceAddressCreateInfoEXT::deviceAddress the return value will be the same address that was returned at capture time.

Valid Usage

VUID-vkGetBufferDeviceAddress-bufferDeviceAddress-03324
The bufferDeviceAddress or VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::bufferDeviceAddress feature must be enabled
VUID-vkGetBufferDeviceAddress-device-03325
If device was created with multiple physical devices, then the bufferDeviceAddressMultiDevice or VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::bufferDeviceAddressMultiDevice feature must be enabled

Valid Usage (Implicit)

VUID-vkGetBufferDeviceAddress-device-parameter
device must be a valid VkDevice handle
VUID-vkGetBufferDeviceAddress-pInfo-parameter
pInfo must be a valid pointer to a valid VkBufferDeviceAddressInfo structure

The VkBufferDeviceAddressInfo structure is defined as:

typedef struct VkBufferDeviceAddressInfo {
    VkStructureType    sType;
    const void*        pNext;
    VkBuffer           buffer;
} VkBufferDeviceAddressInfo;

or the equivalent

typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoKHR;

or the equivalent

typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
buffer specifies the buffer whose address is being queried.

Valid Usage

VUID-VkBufferDeviceAddressInfo-buffer-02600
If buffer is non-sparse and was not created with the VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT flag, then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-VkBufferDeviceAddressInfo-buffer-02601
buffer must have been created with VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT

Valid Usage (Implicit)

VUID-VkBufferDeviceAddressInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO
VUID-VkBufferDeviceAddressInfo-pNext-pNext
pNext must be NULL
VUID-VkBufferDeviceAddressInfo-buffer-parameter
buffer must be a valid VkBuffer handle

To query a 64-bit buffer opaque capture address, call:

uint64_t vkGetBufferOpaqueCaptureAddress(
    VkDevice                                    device,
    const VkBufferDeviceAddressInfo*            pInfo);

or the equivalent command

uint64_t vkGetBufferOpaqueCaptureAddressKHR(
    VkDevice                                    device,
    const VkBufferDeviceAddressInfo*            pInfo);

device is the logical device that the buffer was created on.
pInfo is a pointer to a VkBufferDeviceAddressInfo structure specifying the buffer to retrieve an address for.

The 64-bit return value is an opaque capture address of the start of pInfo->buffer.

If the buffer was created with a non-zero value of VkBufferOpaqueCaptureAddressCreateInfo::opaqueCaptureAddress the return value must be the same address.

Valid Usage

VUID-vkGetBufferOpaqueCaptureAddress-None-03326
The bufferDeviceAddress feature must be enabled
VUID-vkGetBufferOpaqueCaptureAddress-device-03327
If device was created with multiple physical devices, then the bufferDeviceAddressMultiDevice feature must be enabled

Valid Usage (Implicit)

VUID-vkGetBufferOpaqueCaptureAddress-device-parameter
device must be a valid VkDevice handle
VUID-vkGetBufferOpaqueCaptureAddress-pInfo-parameter
pInfo must be a valid pointer to a valid VkBufferDeviceAddressInfo structure

14. Shader Interfaces

When a pipeline is created, the set of shaders specified in the corresponding Vk*PipelineCreateInfo structure are implicitly linked at a number of different interfaces.

Shader Input and Output Interface
Vertex Input Interface
Fragment Output Interface
Fragment Input Attachment Interface
Shader Resource Interface

Interface definitions make use of the following SPIR-V decorations:

DescriptorSet and Binding
Location, Component, and Index
Flat, NoPerspective, Centroid, and Sample
Block and BufferBlock
InputAttachmentIndex
Offset, ArrayStride, and MatrixStride
BuiltIn
PassthroughNV

This specification describes valid uses for Vulkan of these decorations. Any other use of one of these decorations is invalid.

14.1. Shader Input and Output Interfaces

When multiple stages are present in a pipeline, the outputs of one stage form an interface with the inputs of the next stage. When such an interface involves a shader, shader outputs are matched against the inputs of the next stage, and shader inputs are matched against the outputs of the previous stage.

All the variables forming the shader input and output interfaces are listed as operands to the OpEntryPoint instruction and are declared with the Input or Output storage classes, respectively, in the SPIR-V module. These generally form the interfaces between consecutive shader stages, regardless of any non-shader stages between the consecutive shader stages.

There are two classes of variables that can be matched between shader stages, built-in variables and user-defined variables. Each class has a different set of matching criteria.

Output variables of a shader stage have undefined values until the shader writes to them or uses the Initializer operand when declaring the variable.

14.1.1. Built-in Interface Block

Shader built-in variables meeting the following requirements define the built-in interface block. They must

be explicitly declared (there are no implicit built-ins),
be identified with a BuiltIn decoration,
form object types as described in the Built-in Variables section, and
be declared in a block whose top-level members are the built-ins.

There must be no more than one built-in interface block per shader per interface.

Built-ins must not have any Location or Component decorations.

14.1.2. User-defined Variable Interface

The non-built-in variables listed by OpEntryPoint with the Input or Output storage class form the user-defined variable interface. These must have SPIR-V numerical types or, recursively, composite types of such types. By default, the components of such types have a width of 32 or 64 bits. If an implementation supports storageInputOutput16, components can also have a width of 16 bits. These variables must be identified with a Location decoration and can also be identified with a Component decoration.

14.1.3. Interface Matching

Interface matching rules only apply to built-ins when they are declared as members of the built-in interface block.

Tessellation control and mesh shader per-vertex output variables and blocks, and tessellation control, tessellation evaluation, and geometry shader per-vertex input variables and blocks are required to be declared as arrays, with each element representing input or output values for a single vertex of a multi-vertex primitive. For the purposes of interface matching, the outermost array dimension of such variables and blocks is ignored.

A user-defined output variable is considered to match an input variable in the subsequent stage if the two variables are declared with the same Location and Component decoration and match in type and decoration, except that interpolation decorations are not required to match. XfbBuffer, XfbStride, Offset, and Stream are also not required to match for the purposes of interface matching. For the purposes of interface matching, variables declared without a Component decoration are considered to have a Component decoration of zero.

Note

Matching rules for passthrough geometry shaders are slightly different and are described in the Passthrough Interface Matching section.

Variables or block members declared as structures are considered to match in type if and only if the structure members match in type, decoration, number, and declaration order. Variables or block members declared as arrays are considered to match in type only if both declarations specify the same element type and size.

At an interface between two non-fragment shader stages, the built-in interface block must match exactly, as described above, except for per-view outputs as described in Mesh Shader Per-View Outputs. At an interface involving the fragment shader inputs, the presence or absence of any built-in output does not affect the interface matching.

At an interface between two shader stages, the user-defined variable interface must match exactly, as described above.

Any input value to a shader stage is well-defined as long as the preceding stages writes to a matching output, as described above.

Additionally, scalar and vector inputs are well-defined if there is a corresponding output satisfying all of the following conditions:

the input and output match exactly in decoration,
the output is a vector with the same basic type and has at least as many components as the input, and
the common component type of the input and output is 16-bit integer or floating-point, or 32-bit integer or floating-point (64-bit component types are excluded).

In this case, the components of the input will be taken from the first components of the output, and any extra components of the output will be ignored.

14.1.4. Location Assignment

This section describes how many locations are consumed by a given type. As mentioned above, some inputs and outputs have an additional level of arrayness relative to other shader inputs and outputs. This outer array level is removed from the type before considering how many locations the type consumes.

The Location value specifies an interface slot comprised of a 32-bit four-component vector conveyed between stages. The Component specifies components within these vector locations. Only types with widths of 16, 32 or 64 are supported in shader interfaces.

Inputs and outputs of the following types consume a single interface location:

16-bit scalar and vector types, and
32-bit scalar and vector types, and
64-bit scalar and 2-component vector types.

64-bit three- and four-component vectors consume two consecutive locations.

If a declared input or output is an array of size n and each element takes m locations, it will be assigned m × n consecutive locations starting with the location specified.

If the declared input or output is an n × m 16-, 32- or 64-bit matrix, it will be assigned multiple locations starting with the location specified. The number of locations assigned for each matrix will be the same as for an n-element array of m-component vectors.

The layout of a structure type used as an Input or Output depends on whether it is also a Block (i.e. has a Block decoration).

If it is a not a Block, then the structure type must have a Location decoration. Its members are assigned consecutive locations in their declaration order, with the first member assigned to the location specified for the structure type. The members, and their nested types, must not themselves have Location decorations.

If the structure type is a Block but without a Location, then each of its members must have a Location decoration. If it is a Block with a Location decoration, then its members are assigned consecutive locations in declaration order, starting from the first member which is initially assigned the location specified for the Block. Any member with its own Location decoration is assigned that location. Each remaining member is assigned the location after the immediately preceding member in declaration order.

The locations consumed by block and structure members are determined by applying the rules above in a depth-first traversal of the instantiated members as though the structure or block member were declared as an input or output variable of the same type.

Any two inputs listed as operands on the same OpEntryPoint must not be assigned the same location, either explicitly or implicitly. Any two outputs listed as operands on the same OpEntryPoint must not be assigned the same location, either explicitly or implicitly.

The number of input and output locations available for a shader input or output interface are limited, and dependent on the shader stage as described in Shader Input and Output Locations. All variables in both the built-in interface block and the user-defined variable interface count against these limits. Each effective Location must have a value less than the number of locations available for the given interface, as specified in the "Locations Available" column in Shader Input and Output Locations.

Table 18. Shader Input and Output Locations
Shader Interface	Locations Available
vertex input	`maxVertexInputAttributes`
vertex output	`maxVertexOutputComponents` / 4
tessellation control input	`maxTessellationControlPerVertexInputComponents` / 4
tessellation control output	`maxTessellationControlPerVertexOutputComponents` / 4
tessellation evaluation input	`maxTessellationEvaluationInputComponents` / 4
tessellation evaluation output	`maxTessellationEvaluationOutputComponents` / 4
geometry input	`maxGeometryInputComponents` / 4
geometry output	`maxGeometryOutputComponents` / 4
fragment input	`maxFragmentInputComponents` / 4
fragment output	`maxFragmentOutputAttachments`

14.1.5. Component Assignment

The Component decoration allows the Location to be more finely specified for scalars and vectors, down to the individual components within a location that are consumed. The components within a location are 0, 1, 2, and 3. A variable or block member starting at component N will consume components N, N+1, N+2, … up through its size. For 16-, and 32-bit types, it is invalid if this sequence of components gets larger than 3. A scalar 64-bit type will consume two of these components in sequence, and a two-component 64-bit vector type will consume all four components available within a location. A three- or four-component 64-bit vector type must not specify a Component decoration. A three-component 64-bit vector type will consume all four components of the first location and components 0 and 1 of the second location. This leaves components 2 and 3 available for other component-qualified declarations.

A scalar or two-component 64-bit data type must not specify a Component decoration of 1 or 3. A Component decoration must not be specified for any type that is not a scalar or vector.

14.2. Vertex Input Interface

When the vertex stage is present in a pipeline, the vertex shader input variables form an interface with the vertex input attributes. The vertex shader input variables are matched by the Location and Component decorations to the vertex input attributes specified in the pVertexInputState member of the VkGraphicsPipelineCreateInfo structure.

The vertex shader input variables listed by OpEntryPoint with the Input storage class form the vertex input interface. These variables must be identified with a Location decoration and can also be identified with a Component decoration.

For the purposes of interface matching: variables declared without a Component decoration are considered to have a Component decoration of zero. The number of available vertex input locations is given by the maxVertexInputAttributes member of the VkPhysicalDeviceLimits structure.

See Attribute Location and Component Assignment for details.

All vertex shader inputs declared as above must have a corresponding attribute and binding in the pipeline.

14.3. Fragment Output Interface

When the fragment stage is present in a pipeline, the fragment shader outputs form an interface with the output attachments of the current subpass. The fragment shader output variables are matched by the Location and Component decorations to the color attachments specified in the pColorAttachments array of the VkSubpassDescription structure describing the subpass that the fragment shader is executed in.

The fragment shader output variables listed by OpEntryPoint with the Output storage class form the fragment output interface. These variables must be identified with a Location decoration. They can also be identified with a Component decoration and/or an Index decoration. For the purposes of interface matching: variables declared without a Component decoration are considered to have a Component decoration of zero, and variables declared without an Index decoration are considered to have an Index decoration of zero.

A fragment shader output variable identified with a Location decoration of i is directed to the color attachment indicated by pColorAttachments[i], after passing through the blending unit as described in Blending, if enabled. Locations are consumed as described in Location Assignment. The number of available fragment output locations is given by the maxFragmentOutputAttachments member of the VkPhysicalDeviceLimits structure.

Components of the output variables are assigned as described in Component Assignment. Output components identified as 0, 1, 2, and 3 will be directed to the R, G, B, and A inputs to the blending unit, respectively, or to the output attachment if blending is disabled. If two variables are placed within the same location, they must have the same underlying type (floating-point or integer). The input values to blending or color attachment writes are undefined for components which do not correspond to a fragment shader output.

Fragment outputs identified with an Index of zero are directed to the first input of the blending unit associated with the corresponding Location. Outputs identified with an Index of one are directed to the second input of the corresponding blending unit.

No component aliasing of output variables is allowed, that is there must not be two output variables which have the same location, component, and index, either explicitly declared or implied.

Output values written by a fragment shader must be declared with either OpTypeFloat or OpTypeInt, and a Width of 32. If storageInputOutput16 is supported, output values written by a fragment shader can be also declared with either OpTypeFloat or OpTypeInt and a Width of 16. Composites of these types are also permitted. If the color attachment has a signed or unsigned normalized fixed-point format, color values are assumed to be floating-point and are converted to fixed-point as described in Conversion from Floating-Point to Normalized Fixed-Point; If the color attachment has an integer format, color values are assumed to be integers and converted to the bit-depth of the target. Any value that cannot be represented in the attachment’s format is undefined. For any other attachment format no conversion is performed. If the type of the values written by the fragment shader do not match the format of the corresponding color attachment, the resulting values are undefined for those components.

14.4. Fragment Input Attachment Interface

When a fragment stage is present in a pipeline, the fragment shader subpass inputs form an interface with the input attachments of the current subpass. The fragment shader subpass input variables are matched by InputAttachmentIndex decorations to the input attachments specified in the pInputAttachments array of the VkSubpassDescription structure describing the subpass that the fragment shader is executed in.

The fragment shader subpass input variables with the UniformConstant storage class and a decoration of InputAttachmentIndex that are statically used by OpEntryPoint form the fragment input attachment interface. These variables must be declared with a type of OpTypeImage, a Dim operand of SubpassData, and a Sampled operand of 2.

A subpass input variable identified with an InputAttachmentIndex decoration of i reads from the input attachment indicated by pInputAttachments[i] member of VkSubpassDescription. If the subpass input variable is declared as an array of size N, it consumes N consecutive input attachments, starting with the index specified. There must not be more than one input variable with the same InputAttachmentIndex whether explicitly declared or implied by an array declaration. The number of available input attachment indices is given by the maxPerStageDescriptorInputAttachments member of the VkPhysicalDeviceLimits structure.

Variables identified with the InputAttachmentIndex must only be used by a fragment stage. The basic data type (floating-point, integer, unsigned integer) of the subpass input must match the basic format of the corresponding input attachment, or the values of subpass loads from these variables are undefined.

See Input Attachment for more details.

14.5. Shader Resource Interface

When a shader stage accesses buffer or image resources, as described in the Resource Descriptors section, the shader resource variables must be matched with the pipeline layout that is provided at pipeline creation time.

The set of shader resources that form the shader resource interface for a stage are the variables statically used by OpEntryPoint with the storage class of Uniform, UniformConstant, or PushConstant. For the fragment shader, this includes the fragment input attachment interface.

The shader resource interface consists of two sub-interfaces: the push constant interface and the descriptor set interface.

14.5.1. Push Constant Interface

The shader variables defined with a storage class of PushConstant that are statically used by the shader entry points for the pipeline define the push constant interface. They must be:

typed as OpTypeStruct,
identified with a Block decoration, and
laid out explicitly using the Offset, ArrayStride, and MatrixStride decorations as specified in Offset and Stride Assignment.

There must be no more than one push constant block statically used per shader entry point.

Each statically used member of a push constant block must be placed at an Offset such that the entire member is entirely contained within the VkPushConstantRange for each OpEntryPoint that uses it, and the stageFlags for that range must specify the appropriate VkShaderStageFlagBits for that stage. The Offset decoration for any member of a push constant block must not cause the space required for that member to extend outside the range [0, maxPushConstantsSize).

Any member of a push constant block that is declared as an array must only be accessed with dynamically uniform indices.

14.5.2. Descriptor Set Interface

The descriptor set interface is comprised of the shader variables with the storage class of StorageBuffer, Uniform or UniformConstant (including the variables in the fragment input attachment interface) that are statically used by the shader entry points for the pipeline.

These variables must have DescriptorSet and Binding decorations specified, which are assigned and matched with the VkDescriptorSetLayout objects in the pipeline layout as described in DescriptorSet and Binding Assignment.

The Image Format of an OpTypeImage declaration must not be Unknown, for variables which are used for OpImageRead, OpImageSparseRead, or OpImageWrite operations, except under the following conditions:

For OpImageWrite, if the shaderStorageImageWriteWithoutFormat feature is enabled and the shader module declares the StorageImageWriteWithoutFormat capability.
For OpImageRead or OpImageSparseRead, if the shaderStorageImageReadWithoutFormat feature is enabled and the shader module declares the StorageImageReadWithoutFormat capability.
For OpImageRead, if Dim is SubpassData (indicating a read from an input attachment).

The Image Format of an OpTypeImage declaration must not be Unknown, for variables which are used for OpAtomic* operations.

Variables identified with the Uniform storage class are used to access transparent buffer backed resources. Such variables must be:

typed as OpTypeStruct, or an array of this type,
identified with a Block or BufferBlock decoration, and
laid out explicitly using the Offset, ArrayStride, and MatrixStride decorations as specified in Offset and Stride Assignment.

Variables identified with the StorageBuffer storage class are used to access transparent buffer backed resources. Such variables must be:

typed as OpTypeStruct, or an array of this type,
identified with a Block decoration, and
laid out explicitly using the Offset, ArrayStride, and MatrixStride decorations as specified in Offset and Stride Assignment.

The Offset decoration for any member of a Block-decorated variable in the Uniform storage class must not cause the space required for that variable to extend outside the range [0, maxUniformBufferRange). The Offset decoration for any member of a Block-decorated variable in the StorageBuffer storage class must not cause the space required for that variable to extend outside the range [0, maxStorageBufferRange).

Variables identified with the Uniform storage class can also be used to access transparent descriptor set backed resources when the variable is assigned to a descriptor set layout binding with a descriptorType of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT. In this case the variable must be typed as OpTypeStruct and cannot be aggregated into arrays of that type. Further, the Offset decoration for any member of such a variable must not cause the space required for that variable to extend outside the range [0,maxInlineUniformBlockSize).

Variables identified with a storage class of UniformConstant and a decoration of InputAttachmentIndex must be declared as described in Fragment Input Attachment Interface.

SPIR-V variables decorated with a descriptor set and binding that identify a combined image sampler descriptor can have a type of OpTypeImage, OpTypeSampler (Sampled=1), or OpTypeSampledImage.

Arrays of any of these types can be indexed with constant integral expressions. The following features must be enabled and capabilities must be declared in order to index such arrays with dynamically uniform or non-uniform indices:

Storage images (except storage texel buffers and input attachments):
- Dynamically uniform: shaderStorageImageArrayDynamicIndexing and StorageImageArrayDynamicIndexing
- Non-uniform: shaderStorageImageArrayNonUniformIndexing and StorageImageArrayNonUniformIndexing
Storage texel buffers:
- Dynamically uniform: shaderStorageTexelBufferArrayDynamicIndexing and StorageTexelBufferArrayDynamicIndexing
- Non-uniform: shaderStorageTexelBufferArrayNonUniformIndexing and StorageTexelBufferArrayNonUniformIndexing
Input attachments:
- Dynamically uniform: shaderInputAttachmentArrayDynamicIndexing and InputAttachmentArrayDynamicIndexing
- Non-uniform: shaderInputAttachmentArrayNonUniformIndexing and InputAttachmentArrayNonUniformIndexing
Sampled images (except uniform texel buffers), samplers and combined image samplers:
- Dynamically uniform: shaderSampledImageArrayDynamicIndexing and SampledImageArrayDynamicIndexing
- Non-uniform: shaderSampledImageArrayNonUniformIndexing and SampledImageArrayNonUniformIndexing
Uniform texel buffers:
- Dynamically uniform: shaderUniformTexelBufferArrayDynamicIndexing and UniformTexelBufferArrayDynamicIndexing
- Non-uniform: shaderUniformTexelBufferArrayNonUniformIndexing and UniformTexelBufferArrayNonUniformIndexing
Uniform buffers:
- Dynamically uniform: shaderUniformBufferArrayDynamicIndexing and UniformBufferArrayDynamicIndexing
- Non-uniform: shaderUniformBufferArrayNonUniformIndexing and UniformBufferArrayNonUniformIndexing
Storage buffers:
- Dynamically uniform: shaderStorageBufferArrayDynamicIndexing and StorageBufferArrayDynamicIndexing
- Non-uniform: shaderStorageBufferArrayNonUniformIndexing and StorageBufferArrayNonUniformIndexing
Acceleration structures:
- No additional capabilities needed.

If an instruction loads from or stores to a resource (including atomics and image instructions) and the resource descriptor being accessed is not dynamically uniform, then the corresponding non-uniform indexing feature must be enabled and the capability must be declared. If an instruction loads from or stores to a resource (including atomics and image instructions) and the resource descriptor being accessed is not uniform, then the corresponding dynamic indexing or non-uniform feature must be enabled and the capability must be declared.

If the combined image sampler enables sampler Y′C_BC_R conversion or samples a subsampled image, it must be indexed only by constant integral expressions when aggregated into arrays in shader code, irrespective of the shaderSampledImageArrayDynamicIndexing feature.

Table 19. Shader Resource and Descriptor Type Correspondence
Resource type	Descriptor Type
sampler	`VK_DESCRIPTOR_TYPE_SAMPLER` or `VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER`
sampled image	`VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE` or `VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER`
storage image	`VK_DESCRIPTOR_TYPE_STORAGE_IMAGE`
combined image sampler	`VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER`
uniform texel buffer	`VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER`
storage texel buffer	`VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER`
uniform buffer	`VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER` or `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC`
storage buffer	`VK_DESCRIPTOR_TYPE_STORAGE_BUFFER` or `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`
input attachment	`VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT`
inline uniform block	`VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT`
acceleration structure	`VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV`

Table 20. Shader Resource and Storage Class Correspondence
Resource type	Storage Class	Type	Decoration(s)¹
sampler	`UniformConstant`	`OpTypeSampler`
sampled image	`UniformConstant`	`OpTypeImage` (`Sampled`=1)
storage image	`UniformConstant`	`OpTypeImage` (`Sampled`=2)
combined image sampler	`UniformConstant`	`OpTypeSampledImage` `OpTypeImage` (`Sampled`=1) `OpTypeSampler`
uniform texel buffer	`UniformConstant`	`OpTypeImage` (`Dim`=`Buffer`, `Sampled`=1)
storage texel buffer	`UniformConstant`	`OpTypeImage` (`Dim`=`Buffer`, `Sampled`=2)
uniform buffer	`Uniform`	`OpTypeStruct`	`Block`, `Offset`, (`ArrayStride`), (`MatrixStride`)
storage buffer	`Uniform`	`OpTypeStruct`	`BufferBlock`, `Offset`, (`ArrayStride`), (`MatrixStride`)
storage buffer	`StorageBuffer`	`OpTypeStruct`	`Block`, `Offset`, (`ArrayStride`), (`MatrixStride`)
input attachment	`UniformConstant`	`OpTypeImage` (`Dim`=`SubpassData`, `Sampled`=2)	`InputAttachmentIndex`
inline uniform block	`Uniform`	`OpTypeStruct`	`Block`, `Offset`, (`ArrayStride`), (`MatrixStride`)

1: in addition to DescriptorSet and Binding

14.5.3. DescriptorSet and Binding Assignment

A variable decorated with a DescriptorSet decoration of s and a Binding decoration of b indicates that this variable is associated with the VkDescriptorSetLayoutBinding that has a binding equal to b in pSetLayouts[s] that was specified in VkPipelineLayoutCreateInfo.

DescriptorSet decoration values must be between zero and maxBoundDescriptorSets minus one, inclusive. Binding decoration values can be any 32-bit unsigned integer value, as described in Descriptor Set Layout. Each descriptor set has its own binding name space.

If the Binding decoration is used with an array, the entire array is assigned that binding value. The array must be a single-dimensional array and size of the array must be no larger than the number of descriptors in the binding. If the array is runtime-sized, then array elements greater than or equal to the size of that binding in the bound descriptor set must not be used. If the array is runtime-sized, the runtimeDescriptorArray feature must be enabled and the RuntimeDescriptorArray capability must be declared. The index of each element of the array is referred to as the arrayElement. For the purposes of interface matching and descriptor set operations, if a resource variable is not an array, it is treated as if it has an arrayElement of zero.

There is a limit on the number of resources of each type that can be accessed by a pipeline stage as shown in Shader Resource Limits. The “Resources Per Stage” column gives the limit on the number each type of resource that can be statically used for an entry point in any given stage in a pipeline. The “Resource Types” column lists which resource types are counted against the limit. Some resource types count against multiple limits.

The pipeline layout may include descriptor sets and bindings which are not referenced by any variables statically used by the entry points for the shader stages in the binding’s stageFlags.

However, if a variable assigned to a given DescriptorSet and Binding is statically used by the entry point for a shader stage, the pipeline layout must contain a descriptor set layout binding in that descriptor set layout and for that binding number, and that binding’s stageFlags must include the appropriate VkShaderStageFlagBits for that stage. The variable must be of a valid resource type determined by its SPIR-V type and storage class, as defined in Shader Resource and Storage Class Correspondence. The descriptor set layout binding must be of a corresponding descriptor type, as defined in Shader Resource and Descriptor Type Correspondence.

Note

There are no limits on the number of shader variables that can have overlapping set and binding values in a shader; but which resources are statically used has an impact. If any shader variable identifying a resource is statically used in a shader, then the underlying descriptor bound at the declared set and binding must support the declared type in the shader when the shader executes.

If multiple shader variables are declared with the same set and binding values, and with the same underlying descriptor type, they can all be statically used within the same shader. However, accesses are not automatically synchronized, and Aliased decorations should be used to avoid data hazards (see section 2.18.2 Aliasing in the SPIR-V specification).

If multiple shader variables with the same set and binding values are declared in a single shader, but with different declared types, where any of those are not supported by the relevant bound descriptor, that shader can only be executed if the variables with the unsupported type are not statically used.

A noteworthy example of using multiple statically-used shader variables sharing the same descriptor set and binding values is a descriptor of type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER that has multiple corresponding shader variables in the UniformConstant storage class, where some could be OpTypeImage, some could be OpTypeSampler (Sampled=1), and some could be OpTypeSampledImage.

Table 21. Shader Resource Limits
Resources per Stage	Resource Types
`maxPerStageDescriptorSamplers` or `maxPerStageDescriptorUpdateAfterBindSamplers`	sampler
	combined image sampler
`maxPerStageDescriptorSampledImages` or `maxPerStageDescriptorUpdateAfterBindSampledImages`	sampled image
	combined image sampler
	uniform texel buffer
`maxPerStageDescriptorStorageImages` or `maxPerStageDescriptorUpdateAfterBindStorageImages`	storage image
	storage texel buffer
`maxPerStageDescriptorUniformBuffers` or `maxPerStageDescriptorUpdateAfterBindUniformBuffers`	uniform buffer
	uniform buffer dynamic
`maxPerStageDescriptorStorageBuffers` or `maxPerStageDescriptorUpdateAfterBindStorageBuffers`	storage buffer
	storage buffer dynamic
`maxPerStageDescriptorInputAttachments` or `maxPerStageDescriptorUpdateAfterBindInputAttachments`	input attachment¹
`maxPerStageDescriptorInlineUniformBlocks` or `maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks`	inline uniform block

1: Input attachments can only be used in the fragment shader stage

14.5.4. Offset and Stride Assignment

All variables with a storage class of Uniform, StorageBuffer, or PushConstant must be explicitly laid out using the Offset, ArrayStride, and MatrixStride decorations.

Note

The numeric order of Offset decorations does not need to follow member declaration order.

Alignment Requirements

There are different alignment requirements depending on the specific resources and on the features enabled on the device.

The scalar alignment of the type of an OpTypeStruct member is defined recursively as follows:

A scalar of size N has a scalar alignment of N.
A vector or matrix type has a scalar alignment equal to that of its component type.
An array type has a scalar alignment equal to that of its element type.
A structure has a scalar alignment equal to the largest scalar alignment of any of its members.

The base alignment of the type of an OpTypeStruct member is defined recursively as follows:

A scalar has a base alignment equal to its scalar alignment.
A two-component vector has a base alignment equal to twice its scalar alignment.
A three- or four-component vector has a base alignment equal to four times its scalar alignment.
An array has a base alignment equal to the base alignment of its element type.
A structure has a base alignment equal to the largest base alignment of any of its members.
A row-major matrix of C columns has a base alignment equal to the base alignment of a vector of C matrix components.
A column-major matrix has a base alignment equal to the base alignment of the matrix column type.

The extended alignment of the type of an OpTypeStruct member is similarly defined as follows:

A scalar, vector or matrix type has an extended alignment equal to its base alignment.
An array or structure type has an extended alignment equal to the largest extended alignment of any of its members, rounded up to a multiple of 16.

A member is defined to improperly straddle if either of the following are true:

It is a vector with total size less than or equal to 16 bytes, and has Offset decorations placing its first byte at F and its last byte at L, where floor(F / 16) != floor(L / 16).
It is a vector with total size greater than 16 bytes and has its Offset decorations placing its first byte at a non-integer multiple of 16.

Standard Buffer Layout

Every member of an OpTypeStruct with storage class of Uniform, StorageBuffer, or PushConstant must be aligned according to the first matching rule as follows:

If the scalarBlockLayout feature is enabled on the device then every member must be aligned according to its scalar alignment.
All vectors must be aligned according to their scalar alignment.
If the uniformBufferStandardLayout feature is not enabled on the device, then any member of an OpTypeStruct with a storage class of Uniform and a decoration of Block must be aligned according to its extended alignment.
Every other member must be aligned according to its base alignment.

Note

Even if scalar alignment is supported, it is generally more performant to use the base alignment.

The memory layout must obey the following rules:

The Offset decoration of any member must be a multiple of its alignment.
Any ArrayStride or MatrixStride decoration must be a multiple of the alignment of the array or matrix as defined above.

Unless the scalarBlockLayout feature is enabled on the device:

Vectors must not improperly straddle, as defined above.
The Offset decoration of a member must not place it between the end of a structure or an array and the next multiple of the alignment of that structure or array.

Note

The std430 layout in GLSL satisfies these rules for types using the base alignment. The std140 layout satisfies the rules for types using the extended alignment.

14.6. Built-In Variables

Built-in variables are accessed in shaders by declaring a variable decorated with a BuiltIn SPIR-V decoration. The meaning of each BuiltIn decoration is as follows. In the remainder of this section, the name of a built-in is used interchangeably with a term equivalent to a variable decorated with that particular built-in. Built-ins that represent integer values can be declared as either signed or unsigned 32-bit integers.

As mentioned above, some inputs and outputs have an additional level of arrayness relative to other shader inputs and outputs. This level of arrayness is not included in the type descriptions below, but must be included when declaring the built-in.

BaryCoordNV: The BaryCoordNV decoration can be used to decorate a fragment shader input variable. This variable will contain a three-component floating-point vector with barycentric weights that indicate the location of the fragment relative to the screen-space locations of vertices of its primitive, obtained using perspective interpolation.

The BaryCoordNV decoration must be used only within fragment shaders.

The variable decorated with BaryCoordNV must be declared using the Input storage class.

The variable decorated with BaryCoordNV must be declared as three-component vector of 32-bit floating-point values.
BaryCoordNoPerspAMD: The BaryCoordNoPerspAMD decoration can be used to decorate a fragment shader input variable. This variable will contain the (I,J) pair of the barycentric coordinates corresponding to the fragment evaluated using linear interpolation at the fragment’s center. The K coordinate of the barycentric coordinates can be derived given the identity I + J + K = 1.0.

BaryCoordNoPerspNV: The BaryCoordNoPerspNV decoration can be used to decorate a fragment shader input variable. This variable will contain a three-component floating-point vector with barycentric weights that indicate the location of the fragment relative to the screen-space locations of vertices of its primitive, obtained using linear interpolation.

The BaryCoordNoPerspNV decoration must be used only within fragment shaders.

The variable decorated with BaryCoordNoPerspNV must be declared using the Input storage class.

The variable decorated with BaryCoordNoPerspNV must be declared as three-component vector of 32-bit floating-point values.
BaryCoordNoPerspCentroidAMD: The BaryCoordNoPerspCentroidAMD decoration can be used to decorate a fragment shader input variable. This variable will contain the (I,J) pair of the barycentric coordinates corresponding to the fragment evaluated using linear interpolation at the centroid. The K coordinate of the barycentric coordinates can be derived given the identity I + J + K = 1.0.
BaryCoordNoPerspSampleAMD: The BaryCoordNoPerspCentroidAMD decoration can be used to decorate a fragment shader input variable. This variable will contain the (I,J) pair of the barycentric coordinates corresponding to the fragment evaluated using linear interpolation at each covered sample. The K coordinate of the barycentric coordinates can be derived given the identity I + J + K = 1.0.
BaryCoordPullModelAMD: The BaryCoordPullModelAMD decoration can be used to decorate a fragment shader input variable. This variable will contain (1/W, 1/I, 1/J) evaluated at the fragment center and can be used to calculate gradients and then interpolate I, J, and W at any desired sample location.
BaryCoordSmoothAMD: The BaryCoordSmoothAMD decoration can be used to decorate a fragment shader input variable. This variable will contain the (I,J) pair of the barycentric coordinates corresponding to the fragment evaluated using perspective interpolation at the fragment’s center. The K coordinate of the barycentric coordinates can be derived given the identity I + J + K = 1.0.
BaryCoordSmoothCentroidAMD: The BaryCoordSmoothCentroidAMD decoration can be used to decorate a fragment shader input variable. This variable will contain the (I,J) pair of the barycentric coordinates corresponding to the fragment evaluated using perspective interpolation at the centroid. The K coordinate of the barycentric coordinates can be derived given the identity I + J + K = 1.0.
BaryCoordSmoothSampleAMD: The BaryCoordSmoothCentroidAMD decoration can be used to decorate a fragment shader input variable. This variable will contain the (I,J) pair of the barycentric coordinates corresponding to the fragment evaluated using perspective interpolation at each covered sample. The K coordinate of the barycentric coordinates can be derived given the identity I + J + K = 1.0.

BaseInstance: Decorating a variable with the BaseInstance built-in will make that variable contain the integer value corresponding to the first instance that was passed to the command that invoked the current vertex shader invocation. BaseInstance is the firstInstance parameter to a direct drawing command or the firstInstance member of a structure consumed by an indirect drawing command.

The BaseInstance decoration must be used only within vertex shaders.

The variable decorated with BaseInstance must be declared using the input storage class.

The variable decorated with BaseInstance must be declared as a scalar 32-bit integer.

BaseVertex: Decorating a variable with the BaseVertex built-in will make that variable contain the integer value corresponding to the first vertex or vertex offset that was passed to the command that invoked the current vertex shader invocation. For non-indexed drawing commands, this variable is the firstVertex parameter to a direct drawing command or the firstVertex member of the structure consumed by an indirect drawing command. For indexed drawing commands, this variable is the vertexOffset parameter to a direct drawing command or the vertexOffset member of the structure consumed by an indirect drawing command.

The BaseVertex decoration must be used only within vertex shaders.

The variable decorated with BaseVertex must be declared using the input storage class.

The variable decorated with BaseVertex must be declared as a scalar 32-bit integer.
ClipDistance: Decorating a variable with the ClipDistance built-in decoration will make that variable contain the mechanism for controlling user clipping. ClipDistance is an array such that the i^th element of the array specifies the clip distance for plane i. A clip distance of 0 means the vertex is on the plane, a positive distance means the vertex is inside the clip half-space, and a negative distance means the point is outside the clip half-space.

The ClipDistance decoration must be used only within mesh, vertex, fragment, tessellation control, tessellation evaluation, and geometry shaders.

In mesh or vertex shaders, any variable decorated with ClipDistance must be declared using the Output storage class.

In fragment shaders, any variable decorated with ClipDistance must be declared using the Input storage class.

In tessellation control, tessellation evaluation, or geometry shaders, any variable decorated with ClipDistance must not be in a storage class other than Input or Output.

Any variable decorated with ClipDistance must be declared as an array of 32-bit floating-point values.

Note

The array variable decorated with ClipDistance is explicitly sized by the shader.

Note

In the last vertex processing stage, these values will be linearly interpolated across the primitive and the portion of the primitive with interpolated distances less than 0 will be considered outside the clip volume. If ClipDistance is then used by a fragment shader, ClipDistance contains these linearly interpolated values.

ClipDistancePerViewNV: Decorating a variable with the ClipDistancePerViewNV built-in decoration will make that variable contain the per-view clip distances. The per-view clip distances have the same semantics as ClipDistance.

The ClipDistancePerViewNV must be used only within mesh shaders.

Any variable decorated with ClipDistancePerViewNV must be declared using the Output storage class, and must also be decorated with the PerViewNV decoration.

Any variable decorated with ClipDistancePerViewNV must be declared as a two-dimensional array of 32-bit floating-point values.
CullDistance: Decorating a variable with the CullDistance built-in decoration will make that variable contain the mechanism for controlling user culling. If any member of this array is assigned a negative value for all vertices belonging to a primitive, then the primitive is discarded before rasterization.

The CullDistance decoration must be used only within mesh, vertex, fragment, tessellation control, tessellation evaluation, and geometry shaders.

In mesh or vertex shaders, any variable decorated with CullDistance must be declared using the Output storage class.

In fragment shaders, any variable decorated with CullDistance must be declared using the Input storage class.

In tessellation control, tessellation evaluation, or geometry shaders, any variable decorated with CullDistance must not be declared in a storage class other than input or output.

Any variable decorated with CullDistance must be declared as an array of 32-bit floating-point values.

Note

In fragment shaders, the values of the CullDistance array are linearly interpolated across each primitive.

Note

If CullDistance decorates an input variable, that variable will contain the corresponding value from the CullDistance decorated output variable from the previous shader stage.

CullDistancePerViewNV: Decorating a variable with the CullDistancePerViewNV built-in decoration will make that variable contain the per-view cull distances. The per-view clip distances have the same semantics as CullDistance.

The CullDistancePerViewNV must be used only within mesh shaders.

Any variable decorated with CullDistancePerViewNV must be declared using the Output storage class, and must also be decorated with the PerViewNV decoration.

Any variable decorated with CullDistancePerViewNV must be declared as a two-dimensional array of 32-bit floating-point values.

DeviceIndex: The DeviceIndex decoration can be applied to a shader input which will be filled with the device index of the physical device that is executing the current shader invocation. This value will be in the range \([0,max(1,physicalDeviceCount))\), where physicalDeviceCount is the physicalDeviceCount member of VkDeviceGroupDeviceCreateInfo.

The DeviceIndex decoration can be used in any shader.

The variable decorated with DeviceIndex must be declared using the Input storage class.

The variable decorated with DeviceIndex must be declared as a scalar 32-bit integer.

DrawIndex: Decorating a variable with the DrawIndex built-in will make that variable contain the integer value corresponding to the zero-based index of the drawing command that invoked the current task, mesh, or vertex shader invocation. For indirect drawing commands, DrawIndex begins at zero and increments by one for each draw command executed. The number of draw commands is given by the drawCount parameter. For direct drawing commands, DrawIndex is always zero. DrawIndex is dynamically uniform.

The DrawIndex decoration must be used only within task, mesh or vertex shaders.

The variable decorated with DrawIndex must be declared using the input storage class.

The variable decorated with DrawIndex must be declared as a scalar 32-bit integer.

When task or mesh shaders are used, only the first active stage will have proper access to the variable, other stages will have undefined values.
FragCoord: Decorating a variable with the FragCoord built-in decoration will make that variable contain the framebuffer coordinate \((x,y,z,\frac{1}{w})\) of the fragment being processed. The (x,y) coordinate (0,0) is the upper left corner of the upper left pixel in the framebuffer.

When Sample Shading is enabled, the x and y components of FragCoord reflect the location of one of the samples corresponding to the shader invocation.

Otherwise, the x and y components of FragCoord reflect the location of the center of the fragment.

The z component of FragCoord is the interpolated depth value of the primitive.

The w component is the interpolated \(\frac{1}{w}\).

The FragCoord decoration must be used only within fragment shaders.

The variable decorated with FragCoord must be declared using the Input storage class.

The Centroid interpolation decoration is ignored, but allowed, on FragCoord.

The variable decorated with FragCoord must be declared as a four-component vector of 32-bit floating-point values.
FragDepth: To have a shader supply a fragment-depth value, the shader must declare the DepthReplacing execution mode. Such a shader’s fragment-depth value will come from the variable decorated with the FragDepth built-in decoration.

This value will be used for any subsequent depth testing performed by the implementation or writes to the depth attachment.

The FragDepth decoration must be used only within fragment shaders.

The variable decorated with FragDepth must be declared using the Output storage class.

The variable decorated with FragDepth must be declared as a scalar 32-bit floating-point value.

FragInvocationCountEXT: Decorating a variable with the FragInvocationCountEXT built-in decoration will make that variable contain the maximum number of fragment shader invocations for the fragment, as determined by minSampleShading.

The FragInvocationCountEXT decoration must be used only within fragment shaders and the FragmentDensityEXT capability must be declared.

If Sample Shading is not enabled, FragInvocationCountEXT will be filled with a value of 1.

The variable decorated with FragInvocationCountEXT must be declared using the Input storage class.

The variable decorated with FragInvocationCountEXT must be declared as a scalar 32-bit integer.

FragSizeEXT: Decorating a variable with the FragSizeEXT built-in decoration will make that variable contain the dimensions in pixels of the area that the fragment covers for that invocation.

The FragSizeEXT decoration must be used only within fragment shaders and the FragmentDensityEXT capability must be declared.

If fragment density map is not enabled, FragSizeEXT will be filled with a value of (1,1).

The variable decorated with FragSizeEXT must be declared using the Input storage class.

The variable decorated with FragSizeEXT must be declared as a two-component vector of 32-bit integers.
FragStencilRefEXT: Decorating a variable with the FragStencilRefEXT built-in decoration will make that variable contain the new stencil reference value for all samples covered by the fragment. This value will be used as the stencil reference value used in stencil testing.

To write to FragStencilRefEXT, a shader must declare the StencilRefReplacingEXT execution mode. If a shader declares the StencilRefReplacingEXT execution mode and there is an execution path through the shader that does not set FragStencilRefEXT, then the fragment’s stencil reference value is undefined for executions of the shader that take that path.

The FragStencilRefEXT decoration must be used only within fragment shaders.

The variable decorated with FragStencilRefEXT must be declared using the Output storage class.

The variable decorated with FragStencilRefEXT must be declared as a scalar integer value. Only the least significant s bits of the integer value of the variable decorated with FragStencilRefEXT are considered for stencil testing, where s is the number of bits in the stencil framebuffer attachment, and higher order bits are discarded.
FragmentSizeNV: Decorating a variable with the FragmentSizeNV built-in decoration will make that variable contain the width and height of the fragment.

The FragmentSizeNV decoration must be used only within fragment shaders.

The variable decorated with FragmentSizeNV must be declared using the Input storage class.

The variable decorated with FragmentSizeNV must be declared as a two-component vector of 32-bit integers.
FrontFacing: Decorating a variable with the FrontFacing built-in decoration will make that variable contain whether the fragment is front or back facing. This variable is non-zero if the current fragment is considered to be part of a front-facing polygon primitive or of a non-polygon primitive and is zero if the fragment is considered to be part of a back-facing polygon primitive.

The FrontFacing decoration must be used only within fragment shaders.

The variable decorated with FrontFacing must be declared using the Input storage class.

The variable decorated with FrontFacing must be declared as a boolean.
FullyCoveredEXT: Decorating a variable with the FullyCoveredEXT built-in decoration will make that variable indicate whether the fragment area is fully covered by the generating primitive. This variable is non-zero if conservative rasterization is enabled and the current fragment area is fully covered by the generating primitive, and is zero if the fragment is not covered or partially covered, or conservative rasterization is disabled.

The FullyCoveredEXT decoration must be used only within fragment shaders and the FragmentFullyCoveredEXT capability must be declared.

The variable decorated with FullyCoveredEXT must be declared using the Input storage class.

The variable decorated with FullyCoveredEXT must be declared as a boolean.

If the implementation supports VkPhysicalDeviceConservativeRasterizationPropertiesEXT::conservativeRasterizationPostDepthCoverage and the PostDepthCoverage execution mode is specified the SampleMask built-in input variable will reflect the coverage after the early per-fragment depth and stencil tests are applied. If VkPhysicalDeviceConservativeRasterizationPropertiesEXT::conservativeRasterizationPostDepthCoverage is not supported the PostDepthCoverage execution mode must not be specified.
GlobalInvocationId: Decorating a variable with the GlobalInvocationId built-in decoration will make that variable contain the location of the current invocation within the global workgroup. Each component is equal to the index of the local workgroup multiplied by the size of the local workgroup plus LocalInvocationId.

The GlobalInvocationId decoration must be used only within task, mesh, or compute shaders.

The variable decorated with GlobalInvocationId must be declared using the Input storage class.

The variable decorated with GlobalInvocationId must be declared as a three-component vector of 32-bit integers.
HelperInvocation: Decorating a variable with the HelperInvocation built-in decoration will make that variable contain whether the current invocation is a helper invocation. This variable is non-zero if the current fragment being shaded is a helper invocation and zero otherwise. A helper invocation is an invocation of the shader that is produced to satisfy internal requirements such as the generation of derivatives.

The HelperInvocation decoration must be used only within fragment shaders.

The variable decorated with HelperInvocation must be declared using the Input storage class.

The variable decorated with HelperInvocation must be declared as a boolean.

Note

It is very likely that a helper invocation will have a value of SampleMask fragment shader input value that is zero.

HitKindNV: A variable decorated with the HitKindNV decoration will describe the intersection that triggered the execution of the current shader. The values are determined by the intersection shader.

The HitKindNV decoration must only be used in any-hit and closest hit shaders.

Any variable decorated with HitKindNV must be declared using the Input storage class.

Any variable decorated with HitKindNV must be declared as a scalar 32-bit integer.

HitTNV: A variable decorated with the HitTNV decoration is equivalent to a variable decorated with the RayTmaxNV decoration.

The HitTNV decoration must only be used in any-hit and closest hit shaders.

Any variable decorated with HitTNV must be declared using the Input storage class.

Any variable decorated with HitTNV must be declared as a scalar 32-bit floating-point value.

IncomingRayFlagsNV: A variable with the IncomingRayFlagsNV decoration will contain the ray flags passed in to the trace call that invoked this particular shader.

The IncomingRayFlagsNV decoration must only be used in the intersection, any-hit, closest hit, and miss shaders.

Any variable decorated with IncomingRayFlagsNV must be declared using the Input storage class.

Any variable decorated with IncomingRayFlagsNV must be declared as a scalar 32-bit integer.

InstanceCustomIndexNV: A variable decorated with the InstanceCustomIndexNV decoration will contain the application-defined value of the instance that intersects the current ray. Only the lower 24 bits are valid, the upper 8 bits will be ignored.

The InstanceCustomIndexNV decoration must only be used in the intersection, any-hit, and closest hit shaders.

Any variable decorated with InstanceCustomIndexNV must be declared using the Input storage class.

Any variable decorated with InstanceCustomIndexNV must be declared as a scalar 32-bit integer.

InstanceId: Decorating a variable in an intersection, any-hit, or closest hit shader with the InstanceId decoration will make that variable contain the index of the instance that intersects the current ray.

The InstanceId decoration must be used only within intersection, any-hit, or closest hit shaders.

The variable decorated with InstanceId must be declared using the Input storage class.

The variable decorated with InstanceId must be declared as a scalar 32-bit integer.
InvocationId: Decorating a variable with the InvocationId built-in decoration will make that variable contain the index of the current shader invocation in a geometry shader, or the index of the output patch vertex in a tessellation control shader.

In a geometry shader, the index of the current shader invocation ranges from zero to the number of instances declared in the shader minus one. If the instance count of the geometry shader is one or is not specified, then InvocationId will be zero.

The InvocationId decoration must be used only within tessellation control and geometry shaders.

The variable decorated with InvocationId must be declared using the Input storage class.

The variable decorated with InvocationId must be declared as a scalar 32-bit integer.
InvocationsPerPixelNV: Decorating a variable with the InvocationsPerPixelNV built-in decoration will make that variable contain the maximum number of fragment shader invocations per pixel, as derived from the effective shading rate for the fragment. If a primitive does not fully cover a pixel, the number of fragment shader invocations for that pixel may be less than the value of InvocationsPerPixelNV. If the shading rate indicates a fragment covering multiple pixels, then InvocationsPerPixelNV will be one.

The InvocationsPerPixelNV decoration must be used only within fragment shaders.

The variable decorated with InvocationsPerPixelNV must be declared using the Input storage class.

The variable decorated with InvocationsPerPixelNV must be declared as a scalar 32-bit integer.
InstanceIndex: Decorating a variable in a vertex shader with the InstanceIndex built-in decoration will make that variable contain the index of the instance that is being processed by the current vertex shader invocation. InstanceIndex begins at the firstInstance parameter to vkCmdDraw or vkCmdDrawIndexed or at the firstInstance member of a structure consumed by vkCmdDrawIndirect or vkCmdDrawIndexedIndirect.

The InstanceIndex decoration must be used only within vertex shaders.

The variable decorated with InstanceIndex must be declared using the Input storage class.

The variable decorated with InstanceIndex must be declared as a scalar 32-bit integer.

LaunchIDNV: A variable decorated with the LaunchIDNV decoration will specify the index of the work item being process. One work item is generated for each of the width × height × depth items dispatched by a vkCmdTraceRaysNV command. All shader invocations inherit the same value for variables decorated with LaunchIDNV.

The LaunchIDNV decoration must only be used within the ray generation, intersection, any-hit, closest hit, and miss shaders.

Any variable decorated with LaunchIDNV must be declared using the Input storage class.

Any variable decorated with LaunchIDNV must be declared as a three-component vector of 32-bit integer values.

LaunchSizeNV: A variable decorated with the LaunchSizeNV decoration will contain the width, height, and depth dimensions passed to the vkCmdTraceRaysNV command that initiated this shader execution. The width is in the first component, the height is in the second component, and the depth is in the third component.

The LaunchSizeNV decoration must only be used within ray generation, intersection, any-hit, closest hit, and miss shaders.

Any variable decorated with LaunchSizeNV must be declared using the Input storage class.

Any variable decorated with LaunchSizeNV must be declared as a three-component vector of 32-bit integer values.

Layer: Decorating a variable with the Layer built-in decoration will make that variable contain the select layer of a multi-layer framebuffer attachment.

In a mesh, vertex, tessellation evaluation, or geometry shader, any variable decorated with Layer can be written with the framebuffer layer index to which the primitive produced by that shader will be directed.

The last active vertex processing stage (in pipeline order) controls the Layer that is used. Outputs in previous shader stages are not used, even if the last stage fails to write the Layer.

If the last active vertex processing stage shader entry point’s interface does not include a variable decorated with Layer, then the first layer is used. If a vertex processing stage shader entry point’s interface includes a variable decorated with Layer, it must write the same value to Layer for all output vertices of a given primitive. If the Layer value is less than 0 or greater than or equal to the number of layers in the framebuffer, then primitives may still be rasterized, fragment shaders may be executed, and the framebuffer values for all layers are undefined.

The Layer decoration must be used only within mesh, vertex, tessellation evaluation, geometry, and fragment shaders. If the shaderOutputLayer feature is not enabled then the Layer decoration must be used only with geometry, and fragment shaders.

In a mesh, vertex, tessellation evaluation, or geometry shader, any variable decorated with Layer must be declared using the Output storage class. If such a variable is also decorated with ViewportRelativeNV, then the ViewportIndex is added to the layer that is used for rendering and that is made available in the fragment shader. If the shader writes to a variable decorated ViewportMaskNV, then the layer selected has a different value for each viewport a primitive is rendered to.

In a fragment shader, a variable decorated with Layer contains the layer index of the primitive that the fragment invocation belongs to.

In a fragment shader, any variable decorated with Layer must be declared using the Input storage class.

Any variable decorated with Layer must be declared as a scalar 32-bit integer.

LayerPerViewNV: Decorating a variable with the LayerPerViewNV built-in decoration will make that variable contain the per-view layer information. The per-view layer has the same semantics as Layer, for each view.

The LayerPerViewNV must only be used within mesh shaders.

Any variable decorated with LayerPerViewNV must be declared using the Output storage class, and must also be decorated with the PerViewNV decoration.

Any variable decorated with LayerPerViewNV must be declared as an array of scalar 32-bit integer values.
LocalInvocationId: Decorating a variable with the LocalInvocationId built-in decoration will make that variable contain the location of the current task, mesh, or compute shader invocation within the local workgroup. Each component ranges from zero through to the size of the workgroup in that dimension minus one.

The LocalInvocationId decoration must be used only within task, mesh, or compute shaders.

The variable decorated with LocalInvocationId must be declared using the Input storage class.

The variable decorated with LocalInvocationId must be declared as a three-component vector of 32-bit integers.

Note

If the size of the workgroup in a particular dimension is one, then the LocalInvocationId in that dimension will be zero. If the workgroup is effectively two-dimensional, then LocalInvocationId.z will be zero. If the workgroup is effectively one-dimensional, then both LocalInvocationId.y and LocalInvocationId.z will be zero.

LocalInvocationIndex

Decorating a variable with the LocalInvocationIndex built-in decoration will make that variable contain a one-dimensional representation of LocalInvocationId. This is computed as:

LocalInvocationIndex =
    LocalInvocationId.z * WorkgroupSize.x * WorkgroupSize.y +
    LocalInvocationId.y * WorkgroupSize.x +
    LocalInvocationId.x;

The LocalInvocationIndex decoration must be used only within task, mesh, or compute shaders.

The variable decorated with LocalInvocationIndex must be declared using the Input storage class.

The variable decorated with LocalInvocationIndex must be declared as a scalar 32-bit integer.

MeshViewCountNV: Decorating a variable with the MeshViewCountNV built-in decoration will make that variable contain the number of views processed by the current mesh or task shader invocations.

The MeshViewCountNV decoration must only be used in task and mesh shaders.

Any variable decorated with MeshViewCountNV must be declared using the Input storage class.

Any variable decorated with MeshViewCountNV must be declared as a scalar 32-bit integer.

MeshViewIndicesNV: Decorating a variable with the MeshViewIndicesNV built-in decoration will make that variable contain the mesh view indices. The mesh view indices is an array of values where each element holds the view number of one of the views being processed by the current mesh or task shader invocations. The array elements with indices great than or equal to MeshViewCountNV are undefined. If the value of MeshViewIndicesNV[i] is j, then any outputs decorated with PerViewNV will take on the value of array element i when processing primitives for view index j.

The MeshViewIndicesNV decoration must only be used in task and mesh shaders.

Any variable decorated with MeshViewIndicesNV must be declared using the Input storage class.

Any variable decorated with MeshViewIndicesNV must be declared as an array of scalar 32-bit integers.
NumSubgroups: Decorating a variable with the NumSubgroups built-in decoration will make that variable contain the number of subgroups in the local workgroup.

The NumSubgroups decoration must be used only within task, mesh, or compute shaders.

The variable decorated with NumSubgroups must be declared using the Input storage class.

The object decorated with NumSubgroups must be declared as a scalar 32-bit integer.
NumWorkgroups: Decorating a variable with the NumWorkgroups built-in decoration will make that variable contain the number of local workgroups that are part of the dispatch that the invocation belongs to. Each component is equal to the values of the workgroup count parameters passed into the dispatch commands.

The NumWorkgroups decoration must be used only within compute shaders.

The variable decorated with NumWorkgroups must be declared using the Input storage class.

The variable decorated with NumWorkgroups must be declared as a three-component vector of 32-bit integers.

ObjectRayDirectionNV: A variable decorated with the ObjectRayDirectionNV decoration will specify the direction of the ray being processed, in object space.

The ObjectRayDirectionNV decoration must only be used within intersection, any-hit, closest hit, and miss shaders.

Any variable decorated with ObjectRayDirectionNV must be declared using the Input storage class.

Any variable decorated with ObjectRayDirectionNV must be declared as a three-component vector of 32-bit floating-point values.

ObjectRayOriginNV: A variable decorated with the ObjectRayOriginNV decoration will specify the origin of the ray being processed, in object space.

The ObjectRayOriginNV decoration must only be used within intersection, any-hit, closest hit, and miss shaders.

Any variable decorated with ObjectRayOriginNV must be declared using the Input storage class.

Any variable decorated with ObjectRayOriginNV must be declared as a three-component vector of 32-bit floating-point values.

ObjectToWorldNV: A variable decorated with the ObjectToWorldNV decoration will contain the current object-to-world transformation matrix, which is determined by the instance of the current intersection.

The ObjectToWorldNV decoration must only be used within intersection, any-hit, and closest hit shaders.

Any variable decorated with ObjectToWorldNV must be declared using the Input storage class.

Any variable decorated with ObjectToWorldNV must be declared as a matrix with four columns of three-component vectors of 32-bit floating-point values.
PatchVertices: Decorating a variable with the PatchVertices built-in decoration will make that variable contain the number of vertices in the input patch being processed by the shader. A single tessellation control or tessellation evaluation shader can read patches of differing sizes, so the value of the PatchVertices variable may differ between patches.

The PatchVertices decoration must be used only within tessellation control and tessellation evaluation shaders.

The variable decorated with PatchVertices must be declared using the Input storage class.

The variable decorated with PatchVertices must be declared as a scalar 32-bit integer.
PointCoord: Decorating a variable with the PointCoord built-in decoration will make that variable contain the coordinate of the current fragment within the point being rasterized, normalized to the size of the point with origin in the upper left corner of the point, as described in Basic Point Rasterization. If the primitive the fragment shader invocation belongs to is not a point, then the variable decorated with PointCoord contains an undefined value.

The PointCoord decoration must be used only within fragment shaders.

The variable decorated with PointCoord must be declared using the Input storage class.

The variable decorated with PointCoord must be declared as two-component vector of 32-bit floating-point values.

Note

Depending on how the point is rasterized, PointCoord may never reach (0,0) or (1,1).

PointSize: Decorating a variable with the PointSize built-in decoration will make that variable contain the size of point primitives. The value written to the variable decorated with PointSize by the last vertex processing stage in the pipeline is used as the framebuffer-space size of points produced by rasterization.

The PointSize decoration must be used only within mesh, vertex, tessellation control, tessellation evaluation, and geometry shaders.

In a mesh or vertex shader, any variable decorated with PointSize must be declared using the Output storage class.

In a tessellation control, tessellation evaluation, or geometry shader, any variable decorated with PointSize must be declared using either the Input or Output storage class.

Any variable decorated with PointSize must be declared as a scalar 32-bit floating-point value.

Note

When PointSize decorates a variable in the Input storage class, it contains the data written to the output variable decorated with PointSize from the previous shader stage.

Position: Decorating a variable with the Position built-in decoration will make that variable contain the position of the current vertex. In the last vertex processing stage, the value of the variable decorated with Position is used in subsequent primitive assembly, clipping, and rasterization operations.

The Position decoration must be used only within mesh, vertex, tessellation control, tessellation evaluation, and geometry shaders.

In a mesh or vertex shader, any variable decorated with Position must be declared using the Output storage class.

In a tessellation control, tessellation evaluation, or geometry shader, any variable decorated with Position must not be declared in a storage class other than Input or Output.

Any variable decorated with Position must be declared as a four-component vector of 32-bit floating-point values.

Note

When Position decorates a variable in the Input storage class, it contains the data written to the output variable decorated with Position from the previous shader stage.

PositionPerViewNV: Decorating a variable with the PositionPerViewNV built-in decoration will make that variable contain the position of the current vertex, for each view.

The PositionPerViewNV decoration must be used only within mesh, vertex, tessellation control, tessellation evaluation, and geometry shaders.

In a vertex shader, any variable decorated with PositionPerViewNV must be declared using the Output storage class.

In a tessellation control, tessellation evaluation, or geometry shader, any variable decorated with PositionPerViewNV must not be declared in a storage class other than input or output.

Any variable decorated with PositionPerViewNV must be declared as an array of four-component vector of 32-bit floating-point values with at least as many elements as the maximum view in the subpass’s view mask plus one. The array must be indexed by a constant or specialization constant.

Elements of the array correspond to views in a multiview subpass, and those elements corresponding to views in the view mask of the subpass the shader is compiled against will be used as the position value for those views. For the final vertex processing stage in the pipeline, values written to an output variable decorated with PositionPerViewNV are used in subsequent primitive assembly, clipping, and rasterization operations, as with Position. PositionPerViewNV output in an earlier vertex processing stage is available as an input in the subsequent vertex processing stage.

If a shader is compiled against a subpass that has the VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX bit set, then the position values for each view must not differ in any component other than the X component. If the values do differ, one will be chosen in an implementation-dependent manner.

PrimitiveCountNV: Decorating a variable with the PrimitiveCountNV decoration will make that variable contain the primitive count. The primitive count specifies the number of primitives in the output mesh produced by the mesh shader that will be processed by subsequent pipeline stages.

The PrimitiveCountNV decoration must only be used in mesh shaders.

Any variable decorated with PrimitiveCountNV must be declared using the Output storage class.

Any variable decorated with PrimitiveCountNV must be declared as a scalar 32-bit integer.
PrimitiveId: Decorating a variable with the PrimitiveId built-in decoration will make that variable contain the index of the current primitive.

The index of the first primitive generated by a drawing command is zero, and the index is incremented after every individual point, line, or triangle primitive is processed.

For triangles drawn as points or line segments (see Polygon Mode), the primitive index is incremented only once, even if multiple points or lines are eventually drawn.

Variables decorated with PrimitiveId are reset to zero between each instance drawn.

Restarting a primitive topology using primitive restart has no effect on the value of variables decorated with PrimitiveId.

In tessellation control and tessellation evaluation shaders, it will contain the index of the patch within the current set of rendering primitives that correspond to the shader invocation.

In a geometry shader, it will contain the number of primitives presented as input to the shader since the current set of rendering primitives was started.

In a fragment shader, it will contain the primitive index written by the geometry shader if a geometry shader is present, or with the value that would have been presented as input to the geometry shader had it been present.

In an intersection, any-hit, or closest hit shader, it will contain the index within the geometry of the triangle or bounding box being processed.

If a geometry shader is present and the fragment shader reads from an input variable decorated with PrimitiveId, then the geometry shader must write to an output variable decorated with PrimitiveId in all execution paths.

If a mesh shader is present and the fragment shader reads from an input variable decorated with PrimitiveId, then the mesh shader must write to the output variables decorated with PrimitiveId in all execution paths.

The PrimitiveId decoration must be used only within mesh, intersection, any-hit, closest hit, fragment, tessellation control, tessellation evaluation, and geometry shaders.

In an intersection, any-hit, closest hit, tessellation control, or tessellation evaluation shader, any variable decorated with PrimitiveId must be declared using the Input storage class.

In a geometry shader, any variable decorated with PrimitiveId must be declared using either the Input or Output storage class.

In a mesh shader, any variable decorated with PrimitiveId must be declared using the Output storage class.

In a fragment shader, any variable decorated with PrimitiveId must be declared using the Input storage class, and either the Geometry or Tessellation capability must also be declared.

Any variable decorated with PrimitiveId must be declared as a scalar 32-bit integer.

Note

When the PrimitiveId decoration is applied to an output variable in the mesh shader or geometry shader, the resulting value is seen through the PrimitiveId decorated input variable in the fragment shader.

PrimitiveIndicesNV

Decorating a variable with the PrimitiveIndicesNV decoration will make that variable contain the output array of vertex index values. Depending on the output primitive type declared using the execution mode, the indices are split into groups of one (OutputPoints), two (OutputLinesNV), or three (OutputTriangles) indices and each group generates a primitive.

All index values must be in the range [0, N-1], where N is the value specified by the OutputVertices execution mode.

The PrimitiveIndicesNV decoration must only be used in mesh shaders.

Any variable decorated with PrimitiveIndicesNV must be declared using the Output storage class.

Any variable decorated with PrimitiveIndicesNV must be declared as an array of scalar 32-bit integers. The array must be sized according to the primitive type and OutputPrimitivesNV execution modes, where the size is:

the value specified by OutputPrimitivesNV if the execution mode is OutputPoints,
two times the value specified by OutputPrimitivesNV if the execution mode is OutputLinesNV, or
three times the value specified by OutputPrimitivesNV if the execution mode is OutputTrianglesNV.

RayTmaxNV: A variable decorated with the RayTmaxNV decoration will contain the parametric tmax values of the ray being processed. The values are independent of the space in which the ray and origin exist.

The tmax value changes throughout the lifetime of the ray query that produced the intersection. In the closest hit shader, the value reflects the closest distance to the intersected primitive. In the any-hit shader, it reflects the distance to the primitive currently being intersected. In the intersection shader, it reflects the distance to the closest primitive intersected so far. The value can change in the intersection shader after calling OpReportIntersectionNV if the corresponding any-hit shader does not ignore the intersection. In a miss shader, the value is identical to the parameter passed into OpTraceNV.

The RayTmaxNV decoration must only be used with the intersection, any-hit, closest hit, and miss shaders.

Any variable decorated with RayTmaxNV must be declared with the Input storage class.

Any variable decorated with RayTmaxNV must be declared as a scalar 32-bit floating-point value.

RayTminNV: A variable decorated with the RayTminNV decoration will contain the parametric tmin values of the ray being processed. The values are independent of the space in which the ray and origin exist.

The tmin value remains constant for the duration of the ray query.

The RayTminNV decoration must only be used with the intersection, any-hit, closest hit, and miss shaders.

Any variable decorated with RayTminNV must be declared with the Input storage class.

Any variable decorated with RayTminNV must be declared as a scalar 32-bit floating-point value.
SampleId: Decorating a variable with the SampleId built-in decoration will make that variable contain the zero-based index of the sample the invocation corresponds to. SampleId ranges from zero to the number of samples in the framebuffer minus one. If a fragment shader entry point’s interface includes an input variable decorated with SampleId, Sample Shading is considered enabled with a minSampleShading value of 1.0.

The SampleId decoration must be used only within fragment shaders.

The variable decorated with SampleId must be declared using the Input storage class.

The variable decorated with SampleId must be declared as a scalar 32-bit integer.

SampleMask: Decorating a variable with the SampleMask built-in decoration will make any variable contain the sample coverage mask for the current fragment shader invocation.

A variable in the Input storage class decorated with SampleMask will contain a bitmask of the set of samples covered by the primitive generating the fragment during rasterization. It has a sample bit set if and only if the sample is considered covered for this fragment shader invocation. SampleMask[] is an array of integers. Bits are mapped to samples in a manner where bit B of mask M (SampleMask[M]) corresponds to sample 32 × M + B.

When state specifies multiple fragment shader invocations for a given fragment, the sample mask for any single fragment shader invocation specifies the subset of the covered samples for the fragment that correspond to the invocation. In this case, the bit corresponding to each covered sample will be set in exactly one fragment shader invocation.

If the PostDepthCoverage execution mode is specified, the sample is considered covered if and only if the sample is covered by the primitive and the sample passes the early per-fragment tests. Otherwise the sample is considered covered if the sample is covered by the primitive, regardless of the result of the fragment tests.

A variable in the Output storage class decorated with SampleMask is an array of integers forming a bit array in a manner similar an input variable decorated with SampleMask, but where each bit represents coverage as computed by the shader. Modifying the sample mask by writing zero to a bit of SampleMask causes the sample to be considered uncovered. If this variable is also decorated with OverrideCoverageNV, the fragment coverage is replaced with the sample mask bits set in the shader otherwise the fragment coverage is ANDed with the bits of the sample mask. If the fragment shader is being evaluated at any frequency other than per-fragment, bits of the sample mask not corresponding to the current fragment shader invocation are ignored. This array must be sized in the fragment shader either implicitly or explicitly, to be no larger than the implementation-dependent maximum sample-mask (as an array of 32-bit elements), determined by the maximum number of samples. If a fragment shader entry point’s interface includes an output variable decorated with SampleMask, the sample mask will be undefined for any array elements of any fragment shader invocations that fail to assign a value. If a fragment shader entry point’s interface does not include an output variable decorated with SampleMask, the sample mask has no effect on the processing of a fragment.

The SampleMask decoration must be used only within fragment shaders.

Any variable decorated with SampleMask must be declared using either the Input or Output storage class.

Any variable decorated with SampleMask must be declared as an array of 32-bit integers.
SamplePosition: Decorating a variable with the SamplePosition built-in decoration will make that variable contain the sub-pixel position of the sample being shaded. The top left of the pixel is considered to be at coordinate (0,0) and the bottom right of the pixel is considered to be at coordinate (1,1).

If the render pass has a fragment density map attachment, the variable will instead contain the sub-fragment position of the sample being shaded. The top left of the fragment is considered to be at coordinate (0,0) and the bottom right of the fragment is considered to be at coordinate (1,1) for any fragment area.

If a fragment shader entry point’s interface includes an input variable decorated with SamplePosition, Sample Shading is considered enabled with a minSampleShading value of 1.0.

The SamplePosition decoration must be used only within fragment shaders.

The variable decorated with SamplePosition must be declared using the Input storage class. If the current pipeline uses custom sample locations the value of any variable decorated with the SamplePosition built-in decoration is undefined.

The variable decorated with SamplePosition must be declared as a two-component vector of 32-bit floating-point values.

SMCountNV: Decorating a variable with the SMCountNV built-in decoration will make that variable contain the number of SMs on the device.

The variable decorated with SMCountNV must be declared using the Input storage class.

The variable decorated with SMCountNV must be declared as a scalar 32-bit integer value.

SMIDNV: Decorating a variable with the SMIDNV built-in decoration will make that variable contain the ID of the SM on which the current shader invocation is running. This variable is in the range [0, SMCountNV-1].

The variable decorated with SMIDNV must be declared using the Input storage class.

The variable decorated with SMIDNV must be declared as a scalar 32-bit integer value.
SubgroupId: Decorating a variable with the SubgroupId built-in decoration will make that variable contain the index of the subgroup within the local workgroup. This variable is in range [0, NumSubgroups-1].

The SubgroupId decoration must be used only within task, mesh or, compute shaders.

The variable decorated with SubgroupId must be declared using the Input storage class.

The variable decorated with SubgroupId must be declared as a scalar 32-bit integer.

SubgroupEqMask: Decorating a variable with the SubgroupEqMask builtin decoration will make that variable contain the subgroup mask of the current subgroup invocation. The bit corresponding to the SubgroupLocalInvocationId is set in the variable decorated with SubgroupEqMask. All other bits are set to zero.

The variable decorated with SubgroupEqMask must be declared using the Input storage class.

The variable decorated with SubgroupEqMask must be declared as a four-component vector of 32-bit integer values.

SubgroupEqMaskKHR is an alias of SubgroupEqMask.

SubgroupGeMask: Decorating a variable with the SubgroupGeMask builtin decoration will make that variable contain the subgroup mask of the current subgroup invocation. The bits corresponding to the invocations greater than or equal to SubgroupLocalInvocationId through SubgroupSize-1 are set in the variable decorated with SubgroupGeMask. All other bits are set to zero.

The variable decorated with SubgroupGeMask must be declared using the Input storage class.

The variable decorated with SubgroupGeMask must be declared as a four-component vector of 32-bit integer values.

SubgroupGeMaskKHR is an alias of SubgroupGeMask.

SubgroupGtMask: Decorating a variable with the SubgroupGtMask builtin decoration will make that variable contain the subgroup mask of the current subgroup invocation. The bits corresponding to the invocations greater than SubgroupLocalInvocationId through SubgroupSize-1 are set in the variable decorated with SubgroupGtMask. All other bits are set to zero.

The variable decorated with SubgroupGtMask must be declared using the Input storage class.

The variable decorated with SubgroupGtMask must be declared as a four-component vector of 32-bit integer values.

SubgroupGtMaskKHR is an alias of SubgroupGtMask.

SubgroupLeMask: Decorating a variable with the SubgroupLeMask builtin decoration will make that variable contain the subgroup mask of the current subgroup invocation. The bits corresponding to the invocations less than or equal to SubgroupLocalInvocationId are set in the variable decorated with SubgroupLeMask. All other bits are set to zero.

The variable decorated with SubgroupLeMask must be declared using the Input storage class.

The variable decorated with SubgroupLeMask must be declared as a four-component vector of 32-bit integer values.

SubgroupLeMaskKHR is an alias of SubgroupLeMask.

SubgroupLtMask: Decorating a variable with the SubgroupLtMask builtin decoration will make that variable contain the subgroup mask of the current subgroup invocation. The bits corresponding to the invocations less than SubgroupLocalInvocationId are set in the variable decorated with SubgroupLtMask. All other bits are set to zero.

The variable decorated with SubgroupLtMask must be declared using the Input storage class.

The variable decorated with SubgroupLtMask must be declared as a four-component vector of 32-bit integer values.

SubgroupLtMaskKHR is an alias of SubgroupLtMask.

SubgroupLocalInvocationId

Decorating a variable with the SubgroupLocalInvocationId builtin decoration will make that variable contain the index of the invocation within the subgroup. This variable is in range [0,SubgroupSize-1].

The variable decorated with SubgroupLocalInvocationId must be declared using the Input storage class.

The variable decorated with SubgroupLocalInvocationId must be declared as a scalar 32-bit integer.

Note

There is no direct relationship between SubgroupLocalInvocationId and LocalInvocationId or LocalInvocationIndex. If the pipeline was created with VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT, applications can compute their own local invocation index to serve the same purpose:

index = SubgroupLocalInvocationId + SubgroupId * SubgroupSize

If full subgroups are not enabled, some subgroups may be dispatched with inactive invocations that don’t correspond to a local workgroup invocation, making the value of index unreliable.

SubgroupSize: Decorating a variable with the SubgroupSize builtin decoration will make that variable contain the implementation-dependent number of invocations in a subgroup. This value must be a power-of-two integer.

If the pipeline was created with the VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT flag set, the SubgroupSize decorated variable will contain the subgroup size for each subgroup that gets dispatched. This value must be between minSubgroupSize and maxSubgroupSize and must be uniform with subgroup scope. The value may vary across a single draw or dispatch call, and for fragment shaders may vary across a single primitive.

If the pipeline was created with a chained VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure, the SubgroupSize decorated variable will match requiredSubgroupSize.

If the pipeline was not created with the VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT flag set and no VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure was chained, the variable decorated with SubgroupSize will match subgroupSize.

The maximum number of invocations that an implementation can support per subgroup is 128.

The variable decorated with SubgroupSize must be declared using the Input storage class.

The variable decorated with SubgroupSize must be declared as a scalar 32-bit integer.

TaskCountNV: Decorating a variable with the TaskCountNV decoration will make that variable contain the task count. The task count specifies the number of subsequent mesh shader workgroups that get generated upon completion of the task shader.

The TaskCountNV decoration must only be used in task shaders.

Any variable decorated with TaskCountNV must be declared using the Output storage class.

Any variable decorated with TaskCountNV must be declared as a scalar 32-bit integer.
TessCoord: Decorating a variable with the TessCoord built-in decoration will make that variable contain the three-dimensional (u,v,w) barycentric coordinate of the tessellated vertex within the patch. u, v, and w are in the range [0,1] and vary linearly across the primitive being subdivided. For the tessellation modes of Quads or IsoLines, the third component is always zero.

The TessCoord decoration must be used only within tessellation evaluation shaders.

The variable decorated with TessCoord must be declared using the Input storage class.

The variable decorated with TessCoord must be declared as three-component vector of 32-bit floating-point values.
TessLevelOuter: Decorating a variable with the TessLevelOuter built-in decoration will make that variable contain the outer tessellation levels for the current patch.

In tessellation control shaders, the variable decorated with TessLevelOuter can be written to, which controls the tessellation factors for the resulting patch. These values are used by the tessellator to control primitive tessellation and can be read by tessellation evaluation shaders.

In tessellation evaluation shaders, the variable decorated with TessLevelOuter can read the values written by the tessellation control shader.

The TessLevelOuter decoration must be used only within tessellation control and tessellation evaluation shaders.

In a tessellation control shader, any variable decorated with TessLevelOuter must be declared using the Output storage class.

In a tessellation evaluation shader, any variable decorated with TessLevelOuter must be declared using the Input storage class.

Any variable decorated with TessLevelOuter must be declared as an array of size four, containing 32-bit floating-point values.
TessLevelInner: Decorating a variable with the TessLevelInner built-in decoration will make that variable contain the inner tessellation levels for the current patch.

In tessellation control shaders, the variable decorated with TessLevelInner can be written to, which controls the tessellation factors for the resulting patch. These values are used by the tessellator to control primitive tessellation and can be read by tessellation evaluation shaders.

In tessellation evaluation shaders, the variable decorated with TessLevelInner can read the values written by the tessellation control shader.

The TessLevelInner decoration must be used only within tessellation control and tessellation evaluation shaders.

In a tessellation control shader, any variable decorated with TessLevelInner must be declared using the Output storage class.

In a tessellation evaluation shader, any variable decorated with TessLevelInner must be declared using the Input storage class.

Any variable decorated with TessLevelInner must be declared as an array of size two, containing 32-bit floating-point values.
VertexIndex: Decorating a variable with the VertexIndex built-in decoration will make that variable contain the index of the vertex that is being processed by the current vertex shader invocation. For non-indexed draws, this variable begins at the firstVertex parameter to vkCmdDraw or the firstVertex member of a structure consumed by vkCmdDrawIndirect and increments by one for each vertex in the draw. For indexed draws, its value is the content of the index buffer for the vertex plus the vertexOffset parameter to vkCmdDrawIndexed or the vertexOffset member of the structure consumed by vkCmdDrawIndexedIndirect.

The VertexIndex decoration must be used only within vertex shaders.

The variable decorated with VertexIndex must be declared using the Input storage class.

The variable decorated with VertexIndex must be declared as a scalar 32-bit integer.

Note

VertexIndex starts at the same starting value for each instance.

ViewIndex: The ViewIndex decoration can be applied to a shader input which will be filled with the index of the view that is being processed by the current shader invocation.

If multiview is enabled in the render pass, this value will be one of the bits set in the view mask of the subpass the pipeline is compiled against. If multiview is not enabled in the render pass, this value will be zero.

The ViewIndex decoration must not be used within compute shaders.

The variable decorated with ViewIndex must be declared using the Input storage class.

The variable decorated with ViewIndex must be declared as a scalar 32-bit integer.

ViewportIndex: Decorating a variable with the ViewportIndex built-in decoration will make that variable contain the index of the viewport.

In a mesh, vertex, tessellation evaluation, or geometry shader, the variable decorated with ViewportIndex can be written to with the viewport index to which the primitive produced by that shader will be directed.

The selected viewport index is used to select the viewport transform, scissor rectangle, and exclusive scissor rectangle.

The last active vertex processing stage (in pipeline order) controls the ViewportIndex that is used. Outputs in previous shader stages are not used, even if the last stage fails to write the ViewportIndex.

If the last active vertex processing stage shader entry point’s interface does not include a variable decorated with ViewportIndex, then the first viewport is used. If a vertex processing stage shader entry point’s interface includes a variable decorated with ViewportIndex, it must write the same value to ViewportIndex for all output vertices of a given primitive.

The ViewportIndex decoration must be used only within mesh, vertex, tessellation evaluation, geometry, and fragment shaders. If the shaderOutputViewportIndex feature is not enabled then the ViewportIndex decoration must be used only with geometry, and fragment shaders.

In a mesh, vertex, tessellation evaluation, or geometry shader, any variable decorated with ViewportIndex must be declared using the Output storage class.

In a fragment shader, the variable decorated with ViewportIndex contains the viewport index of the primitive that the fragment invocation belongs to.

In a fragment shader, any variable decorated with ViewportIndex must be declared using the Input storage class.

Any variable decorated with ViewportIndex must be declared as a scalar 32-bit integer.

ViewportMaskNV: Decorating a variable with the ViewportMaskNV built-in decoration will make that variable contain the viewport mask.

In a mesh, vertex, tessellation evaluation, or geometry shader, the variable decorated with ViewportMaskNV can be written to with the mask of which viewports the primitive produced by that shader will directed.

The ViewportMaskNV variable must be an array that has ⌈(VkPhysicalDeviceLimits::maxViewports / 32)⌉ elements. When a shader writes to this variable, bit B of element M controls whether a primitive is emitted to viewport 32 × M + B. The viewports indicated by the mask are used to select the viewport transform, scissor rectangle, and exclusive scissor rectangle that a primitive will be transformed by.

The last active vertex processing stage (in pipeline order) controls the ViewportMaskNV that is used. Outputs in previous shader stages are not used, even if the last stage fails to write the ViewportMaskNV. When ViewportMaskNV is written by the final vertex processing stage, any variable decorated with ViewportIndex in the fragment shader will have the index of the viewport that was used in generating that fragment.

If a vertex processing stage shader entry point’s interface includes a variable decorated with ViewportMaskNV, it must write the same value to ViewportMaskNV for all output vertices of a given primitive.

The ViewportMaskNV decoration must be used only within mesh, vertex, tessellation evaluation, and geometry shaders.

Any variable decorated with ViewportMaskNV must be declared using the Output storage class.

Any variable decorated with ViewportMaskNV must be declared as an array of 32-bit integers.

ViewportMaskPerViewNV: Decorating a variable with the ViewportMaskPerViewNV built-in decoration will make that variable contain the mask of viewports primitives are broadcast to, for each view.

The ViewportMaskPerViewNV decoration must be used only within mesh, vertex, tessellation control, tessellation evaluation, and geometry shaders.

Any variable decorated with ViewportMaskPerViewNV must be declared using the Output storage class.

The value written to an element of ViewportMaskPerViewNV in the last vertex processing stage is a bitmask indicating which viewports the primitive will be directed to. The primitive will be broadcast to the viewport corresponding to each non-zero bit of the bitmask, and that viewport index is used to select the viewport transform, scissor rectangle, and exclusive scissor rectangle, for each view. The same values must be written to all vertices in a given primitive, or else the set of viewports used for that primitive is undefined.

Any variable decorated with ViewportMaskPerViewNV must be declared as an array of scalar 32-bit integers with at least as many elements as the maximum view in the subpass’s view mask plus one. The array must be indexed by a constant or specialization constant.

Elements of the array correspond to views in a multiview subpass, and those elements corresponding to views in the view mask of the subpass the shader is compiled against will be used as the viewport mask value for those views. ViewportMaskPerViewNV output in an earlier vertex processing stage is not available as an input in the subsequent vertex processing stage.

Although ViewportMaskNV is an array, ViewportMaskPerViewNV is not a two-dimensional array. Instead, ViewportMaskPerViewNV is limited to 32 viewports.

WarpsPerSMNV: Decorating a variable with the WarpsPerSMNV built-in decoration will make that variable contain the maximum number of warps executing on a SM.

The variable decorated with WarpsPerSMNV must be declared using the Input storage class.

The variable decorated with WarpsPerSMNV must be declared as a scalar 32-bit integer value.

WarpIDNV: Decorating a variable with the WarpIDNV built-in decoration will make that variable contain the ID of the warp on a SM on which the current shader invocation is running. This variable is in the range [0, WarpsPerSMNV-1].

The variable decorated with WarpIDNV must be declared using the Input storage class.

The variable decorated with WarpIDNV must be declared as a scalar 32-bit integer value.
WorkgroupId: Decorating a variable with the WorkgroupId built-in decoration will make that variable contain the global workgroup that the current invocation is a member of. Each component ranges from a base value to a base + count value, based on the parameters passed into the dispatch commands.

The WorkgroupId decoration must be used only within task, mesh, or compute shaders.

The variable decorated with WorkgroupId must be declared using the Input storage class.

The variable decorated with WorkgroupId must be declared as a three-component vector of 32-bit integers.
WorkgroupSize: Decorating an object with the WorkgroupSize built-in decoration will make that object contain the dimensions of a local workgroup. If an object is decorated with the WorkgroupSize decoration, this must take precedence over any execution mode set for LocalSize.

The WorkgroupSize decoration must be used only within task, mesh, or compute shaders.

The object decorated with WorkgroupSize must be a specialization constant or a constant.

The object decorated with WorkgroupSize must be declared as a three-component vector of 32-bit integers.

WorldRayDirectionNV: A variable decorated with the WorldRayDirectionNV decoration will specify the direction of the ray being processed, in world space.

The WorldRayDirectionNV decoration must only be used within intersection, any-hit, closest hit, and miss shaders.

Any variable decorated with WorldRayDirectionNV must be declared using the Input storage class.

Any variable decorated with WorldRayDirectionNV must be declared as a three-component vector of 32-bit floating-point values.

WorldRayOriginNV: A variable decorated with the WorldRayOriginNV decoration will specify the origin of the ray being processed, in world space.

The WorldRayOriginNV decoration must only be used within intersection, any-hit, closest hit, and miss shaders.

Any variable decorated with WorldRayOriginNV must be declared using the Input storage class.

Any variable decorated with WorldRayOriginNV must be declared as a three-component vector of 32-bit floating-point values.

WorldToObjectNV: A variable decorated with the WorldToObjectNV decoration will contain the current world-to-object transformation matrix, which is determined by the instance of the current intersection.

The WorldToObjectNV decoration must only be used within intersection, any-hit, and closest hit shaders.

Any variable decorated with WorldToObjectNV must be declared using the Input storage class.

Any variable decorated with WorldToObjectNV must be declared as a matrix with four columns of three-component vectors of 32-bit floating-point values.

15. Image Operations

15.1. Image Operations Overview

Vulkan Image Operations are operations performed by those SPIR-V Image Instructions which take an OpTypeImage (representing a VkImageView) or OpTypeSampledImage (representing a (VkImageView, VkSampler) pair) and texel coordinates as operands, and return a value based on one or more neighboring texture elements (texels) in the image.

Note

Texel is a term which is a combination of the words texture and element. Early interactive computer graphics supported texture operations on textures, a small subset of the image operations on images described here. The discrete samples remain essentially equivalent, however, so we retain the historical term texel to refer to them.

Image Operations include the functionality of the following SPIR-V Image Instructions:

OpImageSample* and OpImageSparseSample* read one or more neighboring texels of the image, and filter the texel values based on the state of the sampler.
- Instructions with ImplicitLod in the name determine the LOD used in the sampling operation based on the coordinates used in neighboring fragments.
- Instructions with ExplicitLod in the name determine the LOD used in the sampling operation based on additional coordinates.
- Instructions with Proj in the name apply homogeneous projection to the coordinates.
OpImageFetch and OpImageSparseFetch return a single texel of the image. No sampler is used.
OpImage*Gather and OpImageSparse*Gather read neighboring texels and return a single component of each.
OpImageRead (and OpImageSparseRead) and OpImageWrite read and write, respectively, a texel in the image. No sampler is used.
OpImageSampleFootprintNV identifies and returns information about the set of texels in the image that would be accessed by an equivalent OpImageSample* instruction.
Instructions with Dref in the name apply depth comparison on the texel values.
Instructions with Sparse in the name additionally return a sparse residency code.

15.1.1. Texel Coordinate Systems

Images are addressed by texel coordinates. There are three texel coordinate systems:

normalized texel coordinates [0.0, 1.0]
unnormalized texel coordinates [0.0, width / height / depth)
integer texel coordinates [0, width / height / depth)

SPIR-V OpImageFetch, OpImageSparseFetch, OpImageRead, OpImageSparseRead, and OpImageWrite instructions use integer texel coordinates. Other image instructions can use either normalized or unnormalized texel coordinates (selected by the unnormalizedCoordinates state of the sampler used in the instruction), but there are limitations on what operations, image state, and sampler state is supported. Normalized coordinates are logically converted to unnormalized as part of image operations, and certain steps are only performed on normalized coordinates. The array layer coordinate is always treated as unnormalized even when other coordinates are normalized.

Normalized texel coordinates are referred to as (s,t,r,q,a), with the coordinates having the following meanings:

s: Coordinate in the first dimension of an image.
t: Coordinate in the second dimension of an image.
r: Coordinate in the third dimension of an image.
- (s,t,r) are interpreted as a direction vector for Cube images.
q: Fourth coordinate, for homogeneous (projective) coordinates.
a: Coordinate for array layer.

The coordinates are extracted from the SPIR-V operand based on the dimensionality of the image variable and type of instruction. For Proj instructions, the components are in order (s [,t] [,r] q), with t and r being conditionally present based on the Dim of the image. For non-Proj instructions, the coordinates are (s [,t] [,r] [,a]), with t and r being conditionally present based on the Dim of the image and a being conditionally present based on the Arrayed property of the image. Projective image instructions are not supported on Arrayed images.

Unnormalized texel coordinates are referred to as (u,v,w,a), with the coordinates having the following meanings:

u: Coordinate in the first dimension of an image.
v: Coordinate in the second dimension of an image.
w: Coordinate in the third dimension of an image.
a: Coordinate for array layer.

Only the u and v coordinates are directly extracted from the SPIR-V operand, because only 1D and 2D (non-Arrayed) dimensionalities support unnormalized coordinates. The components are in order (u [,v]), with v being conditionally present when the dimensionality is 2D. When normalized coordinates are converted to unnormalized coordinates, all four coordinates are used.

Integer texel coordinates are referred to as (i,j,k,l,n), with the coordinates having the following meanings:

i: Coordinate in the first dimension of an image.
j: Coordinate in the second dimension of an image.
k: Coordinate in the third dimension of an image.
l: Coordinate for array layer.
n: Coordinate for the sample index.

They are extracted from the SPIR-V operand in order (i, [,j], [,k], [,l]), with j and k conditionally present based on the Dim of the image, and l conditionally present based on the Arrayed property of the image. n is conditionally present and is taken from the Sample image operand.

For all coordinate types, unused coordinates are assigned a value of zero.

Figure 3. Texel Coordinate Systems, Linear Filtering

The Texel Coordinate Systems - For the example shown of an 8×4 texel two dimensional image.

Normalized texel coordinates:
- The s coordinate goes from 0.0 to 1.0.
- The t coordinate goes from 0.0 to 1.0.
Unnormalized texel coordinates:
- The u coordinate within the range 0.0 to 8.0 is within the image, otherwise it is outside the image.
- The v coordinate within the range 0.0 to 4.0 is within the image, otherwise it is outside the image.
Integer texel coordinates:
- The i coordinate within the range 0 to 7 addresses texels within the image, otherwise it is outside the image.
- The j coordinate within the range 0 to 3 addresses texels within the image, otherwise it outside the image.
Also shown for linear filtering:
- Given the unnormalized coordinates (u,v), the four texels selected are i₀j₀, i₁j₀, i₀j₁, and i₁j₁.
- The fractions α and β.
- Given the offset Δ_i and Δ_j, the four texels selected by the offset are i₀j'₀, i₁j'₀, i₀j'₁, and i₁j'₁.

Note

For formats with reduced-resolution channels, Δ_i and Δ_j are relative to the resolution of the highest-resolution channel, and therefore may be divided by two relative to the unnormalized coordinate space of the lower-resolution channels.

Figure 4. Texel Coordinate Systems, Nearest Filtering

The Texel Coordinate Systems - For the example shown of an 8×4 texel two dimensional image.

Texel coordinates as above. Also shown for nearest filtering:
- Given the unnormalized coordinates (u,v), the texel selected is ij.
- Given the offset Δ_i and Δ_j, the texel selected by the offset is ij'.

For corner-sampled images, the texel samples are located at the grid intersections instead of the texel centers.

Figure 5. Texel Coordinate Systems, Corner Sampling

15.2. Conversion Formulas

editing-note

(Bill) These Conversion Formulas will likely move to Section 2.7 Fixed-Point Data Conversions (RGB to sRGB and sRGB to RGB) and section 2.6 Numeric Representation and Computation (RGB to Shared Exponent and Shared Exponent to RGB)

15.2.1. RGB to Shared Exponent Conversion

An RGB color (red, green, blue) is transformed to a shared exponent color (red_shared, green_shared, blue_shared, exp_shared) as follows:

First, the components (red, green, blue) are clamped to (red_clamped, green_clamped, blue_clamped) as:

: red_clamped = max(0, min(sharedexp_max, red))
: green_clamped = max(0, min(sharedexp_max, green))
: blue_clamped = max(0, min(sharedexp_max, blue))

where:

\[\begin{aligned} N & = 9 & \text{number of mantissa bits per component} \\ B & = 15 & \text{exponent bias} \\ E_{max} & = 31 & \text{maximum possible biased exponent value} \\ sharedexp_{max} & = \frac{(2^N-1)}{2^N} \times 2^{(E_{max}-B)} \end{aligned}\]

Note

NaN, if supported, is handled as in IEEE 754-2008 minNum() and maxNum(). That is the result is a NaN is mapped to zero.

The largest clamped component, max_clamped is determined:

: max_clamped = max(red_clamped, green_clamped, blue_clamped)

A preliminary shared exponent exp' is computed:

\[\begin{aligned} exp' = \begin{cases} \left \lfloor \log_2(max_{clamped}) \right \rfloor + (B+1) & \text{for}\ max_{clamped} > 2^{-(B+1)} \\ 0 & \text{for}\ max_{clamped} \leq 2^{-(B+1)} \end{cases} \end{aligned}\]

The shared exponent exp_shared is computed:

\[\begin{aligned} max_{shared} = \left \lfloor { \frac{max_{clamped}}{2^{(exp'-B-N)}} + \frac{1}{2} } \right \rfloor \end{aligned}\]

\[\begin{aligned} exp_{shared} = \begin{cases} exp' & \text{for}\ 0 \leq max_{shared} < 2^N \\ exp'+1 & \text{for}\ max_{shared} = 2^N \end{cases} \end{aligned}\]

Finally, three integer values in the range 0 to 2^N are computed:

\[\begin{aligned} red_{shared} & = \left \lfloor { \frac{red_{clamped}}{2^{(exp_{shared}-B-N)}}+ \frac{1}{2} } \right \rfloor \\ green_{shared} & = \left \lfloor { \frac{green_{clamped}}{2^{(exp_{shared}-B-N)}}+ \frac{1}{2} } \right \rfloor \\ blue_{shared} & = \left \lfloor { \frac{blue_{clamped}}{2^{(exp_{shared}-B-N)}}+ \frac{1}{2} } \right \rfloor \end{aligned}\]

15.2.2. Shared Exponent to RGB

A shared exponent color (red_shared, green_shared, blue_shared, exp_shared) is transformed to an RGB color (red, green, blue) as follows:

: \(red = red_{shared} \times {2^{(exp_{shared}-B-N)}}\)
: \(green = green_{shared} \times {2^{(exp_{shared}-B-N)}}\)
: \(blue = blue_{shared} \times {2^{(exp_{shared}-B-N)}}\)

where:

: N = 9 (number of mantissa bits per component)
: B = 15 (exponent bias)

15.3. Texel Input Operations

Texel input instructions are SPIR-V image instructions that read from an image. Texel input operations are a set of steps that are performed on state, coordinates, and texel values while processing a texel input instruction, and which are common to some or all texel input instructions. They include the following steps, which are performed in the listed order:

Validation operations
Format conversion
Texel replacement
Depth comparison
Conversion to RGBA
Component swizzle
Chroma reconstruction
Y′C_BC_R conversion

For texel input instructions involving multiple texels (for sampling or gathering), these steps are applied for each texel that is used in the instruction. Depending on the type of image instruction, other steps are conditionally performed between these steps or involving multiple coordinate or texel values.

If Chroma Reconstruction is implicit, Texel Filtering instead takes place during chroma reconstruction, before sampler Y′C_BC_R conversion occurs.

15.3.1. Texel Input Validation Operations

Texel input validation operations inspect instruction/image/sampler state or coordinates, and in certain circumstances cause the texel value to be replaced or become undefined. There are a series of validations that the texel undergoes.

Instruction/Sampler/Image View Validation

There are a number of cases where a SPIR-V instruction can mismatch with the sampler, the image view, or both. There are a number of cases where the sampler can mismatch with the image view. In such cases the value of the texel returned is undefined.

These cases include:

The sampler borderColor is an integer type and the image view format is not one of the VkFormat integer types or a stencil component of a depth/stencil format.
The sampler borderColor is a float type and the image view format is not one of the VkFormat float types or a depth component of a depth/stencil format.
The sampler borderColor is one of the opaque black colors (VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK or VK_BORDER_COLOR_INT_OPAQUE_BLACK) and the image view VkComponentSwizzle for any of the VkComponentMapping components is not VK_COMPONENT_SWIZZLE_IDENTITY.
The VkImageLayout of any subresource in the image view does not match that specified in VkDescriptorImageInfo::imageLayout used to write the image descriptor.
If the instruction is OpImageRead or OpImageSparseRead and the shaderStorageImageReadWithoutFormat feature is not enabled, or the instruction is OpImageWrite and the shaderStorageImageWriteWithoutFormat feature is not enabled, then the SPIR-V Image Format must be compatible with the image view’s format.
The sampler unnormalizedCoordinates is VK_TRUE and any of the limitations of unnormalized coordinates are violated.
The sampler was created with flags containing VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT and the image was not created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT.
The sampler was not created with flags containing VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT and the image was created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT.
The sampler was created with flags containing VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT and is used with a function that is not OpImageSampleImplicitLod or OpImageSampleExplicitLod, or is used with operands Offset or ConstOffsets.
The SPIR-V instruction is one of the OpImage*Dref* instructions and the sampler compareEnable is VK_FALSE
The SPIR-V instruction is not one of the OpImage*Dref* instructions and the sampler compareEnable is VK_TRUE
The SPIR-V instruction is one of the OpImage*Dref* instructions and the image view format is not one of the depth/stencil formats with a depth component, or the image view aspect is not VK_IMAGE_ASPECT_DEPTH_BIT.
The SPIR-V instruction’s image variable’s properties are not compatible with the image view:
- Rules for viewType:
  - VK_IMAGE_VIEW_TYPE_1D must have Dim = 1D, Arrayed = 0, MS = 0.
  - VK_IMAGE_VIEW_TYPE_2D must have Dim = 2D, Arrayed = 0.
  - VK_IMAGE_VIEW_TYPE_3D must have Dim = 3D, Arrayed = 0, MS = 0.
  - VK_IMAGE_VIEW_TYPE_CUBE must have Dim = Cube, Arrayed = 0, MS = 0.
  - VK_IMAGE_VIEW_TYPE_1D_ARRAY must have Dim = 1D, Arrayed = 1, MS = 0.
  - VK_IMAGE_VIEW_TYPE_2D_ARRAY must have Dim = 2D, Arrayed = 1.
  - VK_IMAGE_VIEW_TYPE_CUBE_ARRAY must have Dim = Cube, Arrayed = 1, MS = 0.
- If the image was created with VkImageCreateInfo::samples equal to VK_SAMPLE_COUNT_1_BIT, the instruction must have MS = 0.
- If the image was created with VkImageCreateInfo::samples not equal to VK_SAMPLE_COUNT_1_BIT, the instruction must have MS = 1.
If the image was created with VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV, the sampler addressing modes must only use a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.
The SPIR-V instruction is OpImageSampleFootprintNV with Dim = 2D and addressModeU or addressModeV in the sampler is not VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.
The SPIR-V instruction is OpImageSampleFootprintNV with Dim = 3D and addressModeU, addressModeV, or addressModeW in the sampler is not VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.

Only OpImageSample* and OpImageSparseSample* can be used with a sampler that enables sampler Y′C_BC_R conversion.

OpImageFetch, OpImageSparseFetch, OpImage*Gather, and OpImageSparse*Gather must not be used with a sampler that enables sampler Y′C_BC_R conversion.

The ConstOffset and Offset operands must not be used with a sampler that enables sampler Y′C_BC_R conversion.

Integer Texel Coordinate Validation

Integer texel coordinates are validated against the size of the image level, and the number of layers and number of samples in the image. For SPIR-V instructions that use integer texel coordinates, this is performed directly on the integer coordinates. For instructions that use normalized or unnormalized texel coordinates, this is performed on the coordinates that result after conversion to integer texel coordinates.

If the integer texel coordinates do not satisfy all of the conditions

: 0 ≤ i < w_s
: 0 ≤ j < h_s
: 0 ≤ k < d_s
: 0 ≤ l < layers
: 0 ≤ n < samples

where:

: w_s = width of the image level
: h_s = height of the image level
: d_s = depth of the image level
: layers = number of layers in the image
: samples = number of samples per texel in the image

then the texel fails integer texel coordinate validation.

There are four cases to consider:

Valid Texel Coordinates
- If the texel coordinates pass validation (that is, the coordinates lie within the image),
then the texel value comes from the value in image memory.
Border Texel
- If the texel coordinates fail validation, and
- If the read is the result of an image sample instruction or image gather instruction, and
- If the image is not a cube image,
then the texel is a border texel and texel replacement is performed.
Invalid Texel
- If the texel coordinates fail validation, and
- If the read is the result of an image fetch instruction, image read instruction, or atomic instruction,
then the texel is an invalid texel and texel replacement is performed.
Cube Map Edge or Corner

Otherwise the texel coordinates lie beyond the edges or corners of the selected cube map face, and Cube map edge handling is performed.

Cube Map Edge Handling

If the texel coordinates lie beyond the edges or corners of the selected cube map face, the following steps are performed. Note that this does not occur when using VK_FILTER_NEAREST filtering within a mip level, since VK_FILTER_NEAREST is treated as using VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.

Cube Map Edge Texel
- If the texel lies beyond the selected cube map face in either only i or only j, then the coordinates (i,j) and the array layer l are transformed to select the adjacent texel from the appropriate neighboring face.
Cube Map Corner Texel
- If the texel lies beyond the selected cube map face in both i and j, then there is no unique neighboring face from which to read that texel. The texel should be replaced by the average of the three values of the adjacent texels in each incident face. However, implementations may replace the cube map corner texel by other methods. The methods are subject to the constraint that for linear filtering if the three available texels have the same value, the resulting filtered texel must have that value, and for cubic filtering if the twelve available samples have the same value, the resulting filtered texel must have that value.

Sparse Validation

If the texel reads from an unbound region of a sparse image, the texel is a sparse unbound texel, and processing continues with texel replacement.

Layout Validation

If all planes of a disjoint multi-planar image are not in the same image layout, the image must not be sampled with sampler Y′C_BC_R conversion enabled.

15.3.2. Format Conversion

Texels undergo a format conversion from the VkFormat of the image view to a vector of either floating point or signed or unsigned integer components, with the number of components based on the number of components present in the format.

Color formats have one, two, three, or four components, according to the format.
Depth/stencil formats are one component. The depth or stencil component is selected by the aspectMask of the image view.

Each component is converted based on its type and size (as defined in the Format Definition section for each VkFormat), using the appropriate equations in 16-Bit Floating-Point Numbers, Unsigned 11-Bit Floating-Point Numbers, Unsigned 10-Bit Floating-Point Numbers, Fixed-Point Data Conversion, and Shared Exponent to RGB. Signed integer components smaller than 32 bits are sign-extended.

If the image view format is sRGB, the color components are first converted as if they are UNORM, and then sRGB to linear conversion is applied to the R, G, and B components as described in the “sRGB EOTF” section of the Khronos Data Format Specification. The A component, if present, is unchanged.

If the image view format is block-compressed, then the texel value is first decoded, then converted based on the type and number of components defined by the compressed format.

15.3.3. Texel Replacement

A texel is replaced if it is one (and only one) of:

a border texel,
an invalid texel, or
a sparse unbound texel.

Border texels are replaced with a value based on the image format and the borderColor of the sampler. The border color is:

Table 22. Border Color B
Sampler `borderColor`	Corresponding Border Color
`VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK`	[B_r, B_g, B_b, B_a] = [0.0, 0.0, 0.0, 0.0]
`VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK`	[B_r, B_g, B_b, B_a] = [0.0, 0.0, 0.0, 1.0]
`VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE`	[B_r, B_g, B_b, B_a] = [1.0, 1.0, 1.0, 1.0]
`VK_BORDER_COLOR_INT_TRANSPARENT_BLACK`	[B_r, B_g, B_b, B_a] = [0, 0, 0, 0]
`VK_BORDER_COLOR_INT_OPAQUE_BLACK`	[B_r, B_g, B_b, B_a] = [0, 0, 0, 1]
`VK_BORDER_COLOR_INT_OPAQUE_WHITE`	[B_r, B_g, B_b, B_a] = [1, 1, 1, 1]

Note

The names VK_BORDER_COLOR_*_TRANSPARENT_BLACK, VK_BORDER_COLOR_*_OPAQUE_BLACK, and VK_BORDER_COLOR_*_OPAQUE_WHITE are meant to describe which components are zeros and ones in the vocabulary of compositing, and are not meant to imply that the numerical value of VK_BORDER_COLOR_INT_OPAQUE_WHITE is a saturating value for integers.

This is substituted for the texel value by replacing the number of components in the image format

Table 23. Border Texel Components After Replacement
Texel Aspect or Format	Component Assignment
Depth aspect	D = B_r
Stencil aspect	S = B_r
One component color format	Color_r = B_r
Two component color format	[Color_r,Color_g] = [B_r,B_g]
Three component color format	[Color_r,Color_g,Color_b] = [B_r,B_g,B_b]
Four component color format	[Color_r,Color_g,Color_b,Color_a] = [B_r,B_g,B_b,B_a]

The value returned by a read of an invalid texel is undefined, unless that read operation is from a buffer resource and the robustBufferAccess feature is enabled. In that case, an invalid texel is replaced as described by the robustBufferAccess feature.

If the VkPhysicalDeviceSparseProperties::residencyNonResidentStrict property is VK_TRUE, a sparse unbound texel is replaced with 0 or 0.0 values for integer and floating-point components of the image format, respectively.

If residencyNonResidentStrict is VK_FALSE, the value of the sparse unbound texel is undefined.

15.3.4. Depth Compare Operation

If the image view has a depth/stencil format, the depth component is selected by the aspectMask, and the operation is a Dref instruction, a depth comparison is performed. The value of the result D is 1.0 if the result of the compare operation is true, and 0.0 otherwise. The compare operation is selected by the compareOp member of the sampler.

\[\begin{aligned} D & = 1.0 & \begin{cases} D_{\textit{ref}} \leq D & \text{for LEQUAL} \\ D_{\textit{ref}} \geq D & \text{for GEQUAL} \\ D_{\textit{ref}} < D & \text{for LESS} \\ D_{\textit{ref}} > D & \text{for GREATER} \\ D_{\textit{ref}} = D & \text{for EQUAL} \\ D_{\textit{ref}} \neq D & \text{for NOTEQUAL} \\ \textit{true} & \text{for ALWAYS} \\ \textit{false} & \text{for NEVER} \end{cases} \\ D & = 0.0 & \text{otherwise} \end{aligned}\]

where, in the depth comparison:

: D_ref = shaderOp.D_ref (from optional SPIR-V operand)
: D (texel depth value)

15.3.5. Conversion to RGBA

The texel is expanded from one, two, or three components to four components based on the image base color:

Table 24. Texel Color After Conversion To RGBA
Texel Aspect or Format	RGBA Color
Depth aspect	[Color_r,Color_g,Color_b, Color_a] = [D,0,0,one]
Stencil aspect	[Color_r,Color_g,Color_b, Color_a] = [S,0,0,one]
One component color format	[Color_r,Color_g,Color_b, Color_a] = [Color_r,0,0,one]
Two component color format	[Color_r,Color_g,Color_b, Color_a] = [Color_r,Color_g,0,one]
Three component color format	[Color_r,Color_g,Color_b, Color_a] = [Color_r,Color_g,Color_b,one]
Four component color format	[Color_r,Color_g,Color_b, Color_a] = [Color_r,Color_g,Color_b,Color_a]

where one = 1.0f for floating-point formats and depth aspects, and one = 1 for integer formats and stencil aspects.

15.3.6. Component Swizzle

All texel input instructions apply a swizzle based on:

the VkComponentSwizzle enums in the components member of the VkImageViewCreateInfo structure for the image being read if sampler Y′C_BC_R conversion is not enabled, and
the VkComponentSwizzle enums in the components member of the VkSamplerYcbcrConversionCreateInfo structure for the sampler Y′C_BC_R conversion if sampler Y′C_BC_R conversion is enabled.

The swizzle can rearrange the components of the texel, or substitute zero or one for any components. It is defined as follows for each color component:

\[\begin{aligned} Color'_{component} & = \begin{cases} Color_r & \text{for RED swizzle} \\ Color_g & \text{for GREEN swizzle} \\ Color_b & \text{for BLUE swizzle} \\ Color_a & \text{for ALPHA swizzle} \\ 0 & \text{for ZERO swizzle} \\ one & \text{for ONE swizzle} \\ identity & \text{for IDENTITY swizzle} \end{cases} \end{aligned}\]

where:

\[\begin{aligned} one & = \begin{cases} & 1.0\text{f} & \text{for floating point components} \\ & 1 & \text{for integer components} \\ \end{cases} \\ identity & = \begin{cases} & Color_r & \text{for}\ component = r \\ & Color_g & \text{for}\ component = g \\ & Color_b & \text{for}\ component = b \\ & Color_a & \text{for}\ component = a \\ \end{cases} \end{aligned}\]

If the border color is one of the VK_BORDER_COLOR_*_OPAQUE_BLACK enums and the VkComponentSwizzle is not VK_COMPONENT_SWIZZLE_IDENTITY for all components (or the equivalent identity mapping), the value of the texel after swizzle is undefined.

15.3.7. Sparse Residency

OpImageSparse* instructions return a structure which includes a residency code indicating whether any texels accessed by the instruction are sparse unbound texels. This code can be interpreted by the OpImageSparseTexelsResident instruction which converts the residency code to a boolean value.

15.3.8. Chroma Reconstruction

In some color models, the color representation is defined in terms of monochromatic light intensity (often called “luma”) and color differences relative to this intensity, often called “chroma”. It is common for color models other than RGB to represent the chroma channels at lower spatial resolution than the luma channel. This approach is used to take advantage of the eye’s lower spatial sensitivity to color compared with its sensitivity to brightness. Less commonly, the same approach is used with additive color, since the green channel dominates the eye’s sensitivity to light intensity and the spatial sensitivity to color introduced by red and blue is lower.

Lower-resolution channels are “downsampled” by resizing them to a lower spatial resolution than the channel representing luminance. The process of reconstructing a full color value for texture access involves accessing both chroma and luma values at the same location. To generate the color accurately, the values of the lower-resolution channels at the location of the luma samples must be reconstructed from the lower-resolution sample locations, an operation known here as “chroma reconstruction” irrespective of the actual color model.

The location of the chroma samples relative to the luma coordinates is determined by the xChromaOffset and yChromaOffset members of the VkSamplerYcbcrConversionCreateInfo structure used to create the sampler Y′C_BC_R conversion.

The following diagrams show the relationship between unnormalized (u,v) coordinates and (i,j) integer texel positions in the luma channel (shown in black, with circles showing integer sample positions) and the texel coordinates of reduced-resolution chroma channels, shown as crosses in red.

Note

If the chroma values are reconstructed at the locations of the luma samples by means of interpolation, chroma samples from outside the image bounds are needed; these are determined according to Wrapping Operation. These diagrams represent this by showing the bounds of the “chroma texel” extending beyond the image bounds, and including additional chroma sample positions where required for interpolation. The limits of a sample for NEAREST sampling is shown as a grid.

Figure 6. 422 downsampling, xChromaOffset=COSITED_EVEN

Figure 7. 422 downsampling, xChromaOffset=MIDPOINT

Figure 8. 420 downsampling, xChromaOffset=COSITED_EVEN, yChromaOffset=COSITED_EVEN

Figure 9. 420 downsampling, xChromaOffset=MIDPOINT, yChromaOffset=COSITED_EVEN

Figure 10. 420 downsampling, xChromaOffset=COSITED_EVEN, yChromaOffset=MIDPOINT

Figure 11. 420 downsampling, xChromaOffset=MIDPOINT, yChromaOffset=MIDPOINT

Reconstruction is implemented in one of two ways:

If the format of the image that is to be sampled sets VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, or the VkSamplerYcbcrConversionCreateInfo’s forceExplicitReconstruction is set to VK_TRUE, reconstruction is performed as an explicit step independent of filtering, described in the Explicit Reconstruction section.

If the format of the image that is to be sampled does not set VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT and if the VkSamplerYcbcrConversionCreateInfo’s forceExplicitReconstruction is set to VK_FALSE, reconstruction is performed as an implicit part of filtering prior to color model conversion, with no separate post-conversion texel filtering step, as described in the Implicit Reconstruction section.

Explicit Reconstruction

If the chromaFilter member of the VkSamplerYcbcrConversionCreateInfo structure is VK_FILTER_NEAREST:
- If the format’s R and B channels are reduced in resolution in just width by a factor of two relative to the G channel (i.e. this is a “_422” format), the \(\tau_{ijk}[level]\) values accessed by texel filtering are reconstructed as follows:
  
  \[\begin{aligned} \tau_R'(i, j) & = \tau_R(\lfloor{i\times 0.5}\rfloor, j)[level] \\ \tau_B'(i, j) & = \tau_B(\lfloor{i\times 0.5}\rfloor, j)[level] \end{aligned}\]
- If the format’s R and B channels are reduced in resolution in width and height by a factor of two relative to the G channel (i.e. this is a “_420” format), the \(\tau_{ijk}[level]\) values accessed by texel filtering are reconstructed as follows:
  
  \[\begin{aligned} \tau_R'(i, j) & = \tau_R(\lfloor{i\times 0.5}\rfloor, \lfloor{j\times 0.5}\rfloor)[level] \\ \tau_B'(i, j) & = \tau_B(\lfloor{i\times 0.5}\rfloor, \lfloor{j\times 0.5}\rfloor)[level] \end{aligned}\]
  
  Note
  
  xChromaOffset and yChromaOffset have no effect if chromaFilter is VK_FILTER_NEAREST for explicit reconstruction.
If the chromaFilter member of the VkSamplerYcbcrConversionCreateInfo structure is VK_FILTER_LINEAR:
- If the format’s R and B channels are reduced in resolution in just width by a factor of two relative to the G channel (i.e. this is a “422” format):
  - If xChromaOffset is VK_CHROMA_LOCATION_COSITED_EVEN:
    
    \[\tau_{RB}'(i,j) = \begin{cases} \tau_{RB}(\lfloor{i\times 0.5}\rfloor,j)[level], & 0.5 \times i = \lfloor{0.5 \times i}\rfloor\\ 0.5\times\tau_{RB}(\lfloor{i\times 0.5}\rfloor,j)[level] + \\ 0.5\times\tau_{RB}(\lfloor{i\times 0.5}\rfloor + 1,j)[level], & 0.5 \times i \neq \lfloor{0.5 \times i}\rfloor \end{cases}\]
  - If xChromaOffset is VK_CHROMA_LOCATION_MIDPOINT:
    
    \[\tau_{RB}(i,j)' = \begin{cases} 0.25 \times \tau_{RB}(\lfloor{i\times 0.5}\rfloor - 1,j)[level] + \\ 0.75 \times \tau_{RB}(\lfloor{i\times 0.5}\rfloor,j)[level], & 0.5 \times i = \lfloor{0.5 \times i}\rfloor\\ 0.75 \times \tau_{RB}(\lfloor{i\times 0.5}\rfloor,j)[level] + \\ 0.25 \times \tau_{RB}(\lfloor{i\times 0.5}\rfloor + 1,j)[level], & 0.5 \times i \neq \lfloor{0.5 \times i}\rfloor \end{cases}\]
- If the format’s R and B channels are reduced in resolution in width and height by a factor of two relative to the G channel (i.e. this is a “420” format), a similar relationship applies. Due to the number of options, these formulae are expressed more concisely as follows:
  
  \[\begin{aligned} i_{RB} & = \begin{cases} 0.5 \times (i) & \textrm{If xChromaOffset = COSITED}\_\textrm{EVEN} \\ 0.5 \times (i - 0.5) & \textrm{If xChromaOffset = MIDPOINT} \end{cases}\\ j_{RB} & = \begin{cases} 0.5 \times (j) & \textrm{If yChromaOffset = COSITED}\_\textrm{EVEN} \\ 0.5 \times (j - 0.5) & \textrm{If yChromaOffset = MIDPOINT} \end{cases}\\ \\ i_{floor} & = \lfloor i_{RB} \rfloor \\ j_{floor} & = \lfloor j_{RB} \rfloor \\ \\ i_{frac} & = i_{RB} - i_{floor} \\ j_{frac} & = j_{RB} - j_{floor} \end{aligned}\]
  
  \[\begin{aligned} \tau_{RB}'(i,j) = & \tau_{RB}( i_{floor}, j_{floor})[level] & \times & ( 1 - i_{frac} ) & & \times & ( 1 - j_{frac} ) & + \\ & \tau_{RB}( 1 + i_{floor}, j_{floor})[level] & \times & ( i_{frac} ) & & \times & ( 1 - j_{frac} ) & + \\ & \tau_{RB}( i_{floor}, 1 + j_{floor})[level] & \times & ( 1 - i_{frac} ) & & \times & ( j_{frac} ) & + \\ & \tau_{RB}( 1 + i_{floor}, 1 + j_{floor})[level] & \times & ( i_{frac} ) & & \times & ( j_{frac} ) & \end{aligned}\]

Note

In the case where the texture itself is bilinearly interpolated as described in Texel Filtering, thus requiring four full-color samples for the filtering operation, and where the reconstruction of these samples uses bilinear interpolation in the chroma channels due to chromaFilter=VK_FILTER_LINEAR, up to nine chroma samples may be required, depending on the sample location.

Implicit Reconstruction

Implicit reconstruction takes place by the samples being interpolated, as required by the filter settings of the sampler, except that chromaFilter takes precedence for the chroma samples.

If chromaFilter is VK_FILTER_NEAREST, an implementation may behave as if xChromaOffset and yChromaOffset were both VK_CHROMA_LOCATION_MIDPOINT, irrespective of the values set.

Note

This will not have any visible effect if the locations of the luma samples coincide with the location of the samples used for rasterization.

The sample coordinates are adjusted by the downsample factor of the channel (such that, for example, the sample coordinates are divided by two if the channel has a downsample factor of two relative to the luma channel):

\[\begin{aligned} u_{RB}' (422/420) &= \begin{cases} 0.5\times (u + 0.5), & \textrm{xChromaOffset = COSITED}\_\textrm{EVEN} \\ 0.5\times u, & \textrm{xChromaOffset = MIDPOINT} \end{cases} \\ v_{RB}' (420) &= \begin{cases} 0.5\times (v + 0.5), & \textrm{yChromaOffset = COSITED}\_\textrm{EVEN} \\ 0.5\times v, & \textrm{yChromaOffset = MIDPOINT} \end{cases} \end{aligned}\]

15.3.9. Sampler Y′C_BC_R Conversion

Sampler Y′C_BC_R conversion performs the following operations, which an implementation may combine into a single mathematical operation:

Sampler Y′C_BC_R Range Expansion
Sampler Y′C_BC_R Model Conversion

Sampler Y′C_BC_R Range Expansion

Sampler Y′C_BC_R range expansion is applied to color channel values after all texel input operations which are not specific to sampler Y′C_BC_R conversion. For example, the input values to this stage have been converted using the normal format conversion rules.

Sampler Y′C_BC_R range expansion is not applied if ycbcrModel is VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY. That is, the shader receives the vector C'_rgba as output by the Component Swizzle stage without further modification.

For other values of ycbcrModel, range expansion is applied to the texel channel values output by the Component Swizzle defined by the components member of VkSamplerYcbcrConversionCreateInfo. Range expansion applies independently to each channel of the image. For the purposes of range expansion and Y′C_BC_R model conversion, the R and B channels contain color difference (chroma) values and the G channel contains luma. The A channel is not modified by sampler Y′C_BC_R range expansion.

The range expansion to be applied is defined by the ycbcrRange member of the VkSamplerYcbcrConversionCreateInfo structure:

If ycbcrRange is VK_SAMPLER_YCBCR_RANGE_ITU_FULL, the following transformations are applied:

\[\begin{aligned} Y' &= C'_{rgba}[G] \\ C_B &= C'_{rgba}[B] - {{2^{(n-1)}}\over{(2^n) - 1}} \\ C_R &= C'_{rgba}[R] - {{2^{(n-1)}}\over{(2^n) - 1}} \end{aligned}\]

Note

These formulae correspond to the “full range” encoding in the “Quantization schemes” chapter of the Khronos Data Format Specification.

Should any future amendments be made to the ITU specifications from which these equations are derived, the formulae used by Vulkan may also be updated to maintain parity.

If ycbcrRange is VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, the following transformations are applied:

\[\begin{aligned} Y' &= {{C'_{rgba}[G] \times (2^n-1) - 16\times 2^{n-8}}\over{219\times 2^{n-8}}} \\ C_B &= {{C'_{rgba}[B] \times \left(2^n-1\right) - 128\times 2^{n-8}}\over{224\times 2^{n-8}}} \\ C_R &= {{C'_{rgba}[R] \times \left(2^n-1\right) - 128\times 2^{n-8}}\over{224\times 2^{n-8}}} \end{aligned}\]

Note

These formulae correspond to the “narrow range” encoding in the “Quantization schemes” chapter of the Khronos Data Format Specification.
n is the bit-depth of the channels in the format.

The precision of the operations performed during range expansion must be at least that of the source format.

An implementation may clamp the results of these range expansion operations such that Y′ falls in the range [0,1], and/or such that C_B and C_R fall in the range [-0.5,0.5].

Sampler Y′C_BC_R Model Conversion

The range-expanded values are converted between color models, according to the color model conversion specified in the ycbcrModel member:

VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY: The color channels are not modified by the color model conversion since they are assumed already to represent the desired color model in which the shader is operating; Y′C_BC_R range expansion is also ignored.
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY: The color channels are not modified by the color model conversion and are assumed to be treated as though in Y′C_BC_R form both in memory and in the shader; Y′C_BC_R range expansion is applied to the channels as for other Y′C_BC_R models, with the vector (C_R,Y′,C_B,A) provided to the shader.
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709: The color channels are transformed from a Y′C_BC_R representation to an R′G′B′ representation as described in the “BT.709 Y′C_BC_R conversion” section of the Khronos Data Format Specification.
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601: The color channels are transformed from a Y′C_BC_R representation to an R′G′B′ representation as described in the “BT.601 Y′C_BC_R conversion” section of the Khronos Data Format Specification.
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020: The color channels are transformed from a Y′C_BC_R representation to an R′G′B′ representation as described in the “BT.2020 Y′C_BC_R conversion” section of the Khronos Data Format Specification.

In this operation, each output channel is dependent on each input channel.

An implementation may clamp the R′G′B′ results of these conversions to the range [0,1].

The precision of the operations performed during model conversion must be at least that of the source format.

The alpha channel is not modified by these model conversions.

Note

Sampling operations in a non-linear color space can introduce color and intensity shifts at sharp transition boundaries. To avoid this issue, the technically precise color correction sequence described in the “Introduction to Color Conversions” chapter of the Khronos Data Format Specification may be performed as follows:

Calculate the unnormalized texel coordinates corresponding to the desired sample position.
For a minFilter or magFilter of VK_FILTER_NEAREST:
1. Calculate (i,j) for the sample location as described under the “nearest filtering” formulae in (u,v,w,a) to (i,j,k,l,n) Transformation And Array Layer Selection
2. Calculate the normalized texel coordinates corresponding to these integer coordinates.
3. Sample using sampler Y′C_BC_R conversion at this location.
For a minFilter or magFilter of VK_FILTER_LINEAR:
1. Calculate (i_[0,1],j_[0,1]) for the sample location as described under the “linear filtering” formulae in (u,v,w,a) to (i,j,k,l,n) Transformation And Array Layer Selection
2. Calculate the normalized texel coordinates corresponding to these integer coordinates.
3. Sample using sampler Y′C_BC_R conversion at each of these locations.
4. Convert the non-linear A′R′G′B′ outputs of the Y′C_BC_R conversions to linear ARGB values as described in the “Transfer Functions” chapter of the Khronos Data Format Specification.
5. Interpolate the linear ARGB values using the α and β values described in the “linear filtering” section of (u,v,w,a) to (i,j,k,l,n) Transformation And Array Layer Selection and the equations in Texel Filtering.

The additional calculations and, especially, additional number of sampling operations in the VK_FILTER_LINEAR case can be expected to have a performance impact compared with using the outputs directly; since the variation from “correct” results are subtle for most content, the application author should determine whether a more costly implementation is strictly necessary. Note that if chromaFilter, and minFilter or magFilter are both VK_FILTER_NEAREST, these operations are redundant and sampling using sampler Y′C_BC_R conversion at the desired sample coordinates will produce the “correct” results without further processing.

15.4. Texel Output Operations

Texel output instructions are SPIR-V image instructions that write to an image. Texel output operations are a set of steps that are performed on state, coordinates, and texel values while processing a texel output instruction, and which are common to some or all texel output instructions. They include the following steps, which are performed in the listed order:

Validation operations
Texel output format conversion

15.4.1. Texel Output Validation Operations

Texel output validation operations inspect instruction/image state or coordinates, and in certain circumstances cause the write to have no effect. There are a series of validations that the texel undergoes.

Texel Format Validation

If the image format of the OpTypeImage is not compatible with the VkImageView’s format, the write causes the contents of the image’s memory to become undefined.

15.4.2. Integer Texel Coordinate Validation

The integer texel coordinates are validated according to the same rules as for texel input coordinate validation.

If the texel fails integer texel coordinate validation, then the write has no effect.

15.4.3. Sparse Texel Operation

If the texel attempts to write to an unbound region of a sparse image, the texel is a sparse unbound texel. In such a case, if the VkPhysicalDeviceSparseProperties::residencyNonResidentStrict property is VK_TRUE, the sparse unbound texel write has no effect. If residencyNonResidentStrict is VK_FALSE, the write may have a side effect that becomes visible to other accesses to unbound texels in any resource, but will not be visible to any device memory allocated by the application.

15.4.4. Texel Output Format Conversion

If the image format is sRGB, a linear to sRGB conversion is applied to the R, G, and B components as described in the “sRGB EOTF” section of the Khronos Data Format Specification. The A component, if present, is unchanged.

Texels then undergo a format conversion from the floating point, signed, or unsigned integer type of the texel data to the VkFormat of the image view. Any unused components are ignored.

Each component is converted based on its type and size (as defined in the Format Definition section for each VkFormat). Floating-point outputs are converted as described in Floating-Point Format Conversions and Fixed-Point Data Conversion. Integer outputs are converted such that their value is preserved. The converted value of any integer that cannot be represented in the target format is undefined.

15.5. Normalized Texel Coordinate Operations

If the image sampler instruction provides normalized texel coordinates, some of the following operations are performed.

15.5.1. Projection Operation

For Proj image operations, the normalized texel coordinates (s,t,r,q,a) and (if present) the D_ref coordinate are transformed as follows:

\[\begin{aligned} s & = \frac{s}{q}, & \text{for 1D, 2D, or 3D image} \\ \\ t & = \frac{t}{q}, & \text{for 2D or 3D image} \\ \\ r & = \frac{r}{q}, & \text{for 3D image} \\ \\ D_{\textit{ref}} & = \frac{D_{\textit{ref}}}{q}, & \text{if provided} \end{aligned}\]

15.5.2. Derivative Image Operations

Derivatives are used for LOD selection. These derivatives are either implicit (in an ImplicitLod image instruction in a fragment shader) or explicit (provided explicitly by shader to the image instruction in any shader).

For implicit derivatives image instructions, the derivatives of texel coordinates are calculated in the same manner as derivative operations. That is:

\[\begin{aligned} \partial{s}/\partial{x} & = dPdx(s), & \partial{s}/\partial{y} & = dPdy(s), & \text{for 1D, 2D, Cube, or 3D image} \\ \partial{t}/\partial{x} & = dPdx(t), & \partial{t}/\partial{y} & = dPdy(t), & \text{for 2D, Cube, or 3D image} \\ \partial{u}/\partial{x} & = dPdx(u), & \partial{u}/\partial{y} & = dPdy(u), & \text{for Cube or 3D image} \end{aligned}\]

Partial derivatives not defined above for certain image dimensionalities are set to zero.

For explicit LOD image instructions, if the optional SPIR-V operand Grad is provided, then the operand values are used for the derivatives. The number of components present in each derivative for a given image dimensionality matches the number of partial derivatives computed above.

If the optional SPIR-V operand Lod is provided, then derivatives are set to zero, the cube map derivative transformation is skipped, and the scale factor operation is skipped. Instead, the floating point scalar coordinate is directly assigned to λ_base as described in Level-of-Detail Operation.

If the image or sampler object used by an implicit derivative image instruction is not uniform across the quad and quadDivergentImplicitLod is not supported, then the derivative and LOD values are undefined. Implicit derivatives are well-defined when the image and sampler and control flow are uniform across the quad, even if they diverge between different quads.

If quadDivergentImplicitLod is supported, then derivatives and implicit LOD values are well-defined even if the image or sampler object are not uniform within a quad. The derivatives are computed as specified above, and the implicit LOD calculation proceeds for each shader invocation using its respective image and sampler object.

15.5.3. Cube Map Face Selection and Transformations

For cube map image instructions, the (s,t,r) coordinates are treated as a direction vector (r_x,r_y,r_z). The direction vector is used to select a cube map face. The direction vector is transformed to a per-face texel coordinate system (s_face,t_face), The direction vector is also used to transform the derivatives to per-face derivatives.

15.5.4. Cube Map Face Selection

The direction vector selects one of the cube map’s faces based on the largest magnitude coordinate direction (the major axis direction). Since two or more coordinates can have identical magnitude, the implementation must have rules to disambiguate this situation.

The rules should have as the first rule that r_z wins over r_y and r_x, and the second rule that r_y wins over r_x. An implementation may choose other rules, but the rules must be deterministic and depend only on (r_x,r_y,r_z).

The layer number (corresponding to a cube map face), the coordinate selections for s_c, t_c, r_c, and the selection of derivatives, are determined by the major axis direction as specified in the following two tables.

Table 25. Cube map face and coordinate selection
Major Axis Direction	Layer Number	Cube Map Face	s_c	t_c	r_c
+r_x	0	Positive X	-r_z	-r_y	r_x
-r_x	1	Negative X	+r_z	-r_y	r_x
+r_y	2	Positive Y	+r_x	+r_z	r_y
-r_y	3	Negative Y	+r_x	-r_z	r_y
+r_z	4	Positive Z	+r_x	-r_y	r_z
-r_z	5	Negative Z	-r_x	-r_y	r_z

Table 26. Cube map derivative selection
Major Axis Direction	∂s_c / ∂x	∂s_c / ∂y	∂t_c / ∂x	∂t_c / ∂y	∂r_c / ∂x	∂r_c / ∂y
+r_x	-∂r_z / ∂x	-∂r_z / ∂y	-∂r_y / ∂x	-∂r_y / ∂y	+∂r_x / ∂x	+∂r_x / ∂y
-r_x	+∂r_z / ∂x	+∂r_z / ∂y	-∂r_y / ∂x	-∂r_y / ∂y	-∂r_x / ∂x	-∂r_x / ∂y
+r_y	+∂r_x / ∂x	+∂r_x / ∂y	+∂r_z / ∂x	+∂r_z / ∂y	+∂r_y / ∂x	+∂r_y / ∂y
-r_y	+∂r_x / ∂x	+∂r_x / ∂y	-∂r_z / ∂x	-∂r_z / ∂y	-∂r_y / ∂x	-∂r_y / ∂y
+r_z	+∂r_x / ∂x	+∂r_x / ∂y	-∂r_y / ∂x	-∂r_y / ∂y	+∂r_z / ∂x	+∂r_z / ∂y
-r_z	-∂r_x / ∂x	-∂r_x / ∂y	-∂r_y / ∂x	-∂r_y / ∂y	-∂r_z / ∂x	-∂r_z / ∂y

15.5.5. Cube Map Coordinate Transformation

\[\begin{aligned} s_{\textit{face}} & = \frac{1}{2} \times \frac{s_c}{|r_c|} + \frac{1}{2} \\ t_{\textit{face}} & = \frac{1}{2} \times \frac{t_c}{|r_c|} + \frac{1}{2} \\ \end{aligned}\]

15.5.6. Cube Map Derivative Transformation

\[\begin{aligned} \frac{\partial{s_{\textit{face}}}}{\partial{x}} &= \frac{\partial}{\partial{x}} \left ( \frac{1}{2} \times \frac{s_{c}}{|r_{c}|} + \frac{1}{2}\right ) \\ \frac{\partial{s_{\textit{face}}}}{\partial{x}} &= \frac{1}{2} \times \frac{\partial}{\partial{x}} \left ( \frac{s_{c}}{|r_{c}|} \right ) \\ \frac{\partial{s_{\textit{face}}}}{\partial{x}} &= \frac{1}{2} \times \left ( \frac{ |r_{c}| \times \partial{s_c}/\partial{x} -s_c \times {\partial{r_{c}}}/{\partial{x}}} {\left ( r_{c} \right )^2} \right ) \end{aligned}\]

\[\begin{aligned} \frac{\partial{s_{\textit{face}}}}{\partial{y}} &= \frac{1}{2} \times \left ( \frac{ |r_{c}| \times \partial{s_c}/\partial{y} -s_c \times {\partial{r_{c}}}/{\partial{y}}} {\left ( r_{c} \right )^2} \right )\\ \frac{\partial{t_{\textit{face}}}}{\partial{x}} &= \frac{1}{2} \times \left ( \frac{ |r_{c}| \times \partial{t_c}/\partial{x} -t_c \times {\partial{r_{c}}}/{\partial{x}}} {\left ( r_{c} \right )^2} \right ) \\ \frac{\partial{t_{\textit{face}}}}{\partial{y}} &= \frac{1}{2} \times \left ( \frac{ |r_{c}| \times \partial{t_c}/\partial{y} -t_c \times {\partial{r_{c}}}/{\partial{y}}} {\left ( r_{c} \right )^2} \right ) \end{aligned}\]

editing-note

(Bill) Note that we never revisited ARB_texture_cubemap after we introduced dependent texture fetches (ARB_fragment_program and ARB_fragment_shader).

The derivatives of s_face and t_face are only valid for non-dependent texture fetches (pre OpenGL 2.0).

15.5.7. Scale Factor Operation, Level-of-Detail Operation and Image Level(s) Selection

LOD selection can be either explicit (provided explicitly by the image instruction) or implicit (determined from a scale factor calculated from the derivatives). The implicit LOD selected can be queried using the SPIR-V instruction OpImageQueryLod, which gives access to the λ' and d_l values, defined below. These values must be computed with mipmapPrecisionBits of accuracy and may be subject to implementation-specific maxima and minima for very large, out-of-range values.

Scale Factor Operation

The magnitude of the derivatives are calculated by:

: m_ux = |∂s/∂x| × w_base
: m_vx = |∂t/∂x| × h_base
: m_wx = |∂r/∂x| × d_base
: m_uy = |∂s/∂y| × w_base
: m_vy = |∂t/∂y| × h_base
: m_wy = |∂r/∂y| × d_base

where:

: ∂t/∂x = ∂t/∂y = 0 (for 1D images)
: ∂r/∂x = ∂r/∂y = 0 (for 1D, 2D or Cube images)

and:

: w_base = image.w
: h_base = image.h
: d_base = image.d

(for the baseMipLevel, from the image descriptor).

For corner-sampled images, the w_base, h_base, and d_base are instead:

: w_base = image.w - 1
: h_base = image.h - 1
: d_base = image.d - 1

A point sampled in screen space has an elliptical footprint in texture space. The minimum and maximum scale factors (ρ_min, ρ_max) should be the minor and major axes of this ellipse.

The scale factors ρ_x and ρ_y, calculated from the magnitude of the derivatives in x and y, are used to compute the minimum and maximum scale factors.

ρ_x and ρ_y may be approximated with functions f_x and f_y, subject to the following constraints:

\[\begin{aligned} & f_x \text{\ is\ continuous\ and\ monotonically\ increasing\ in\ each\ of\ } m_{ux}, m_{vx}, \text{\ and\ } m_{wx} \\ & f_y \text{\ is\ continuous\ and\ monotonically\ increasing\ in\ each\ of\ } m_{uy}, m_{vy}, \text{\ and\ } m_{wy} \end{aligned}\]

\[\begin{aligned} \max(|m_{ux}|, |m_{vx}|, |m_{wx}|) \leq f_{x} \leq \sqrt{2} (|m_{ux}| + |m_{vx}| + |m_{wx}|) \\ \max(|m_{uy}|, |m_{vy}|, |m_{wy}|) \leq f_{y} \leq \sqrt{2} (|m_{uy}| + |m_{vy}| + |m_{wy}|) \end{aligned}\]

editing-note

(Bill) For reviewers only - anticipating questions.

We only support implicit derivatives for normalized texel coordinates.

So we are documenting the derivatives in s,t,r (normalized texel coordinates) rather than u,v,w (unnormalized texel coordinates) as in OpenGL and OpenGL ES specifications. (I know, u,v,w is the way it has been documented since OpenGL V1.0.)

Also there is no reason to have conditional application of w_base, h_base, d_base for rectangle textures either, since they do not support implicit derivatives.

The minimum and maximum scale factors (ρ_min,ρ_max) are determined by:

: ρ_max = max(ρ_x, ρ_y)
: ρ_min = min(ρ_x, ρ_y)

The ratio of anisotropy is determined by:

: η = min(ρ_max/ρ_min, max_Aniso)

where:

: sampler.max_Aniso = maxAnisotropy (from sampler descriptor)
: limits.max_Aniso = maxSamplerAnisotropy (from physical device limits)
: max_Aniso = min(sampler.max_Aniso, limits.max_Aniso)

If ρ_max = ρ_min = 0, then all the partial derivatives are zero, the fragment’s footprint in texel space is a point, and N should be treated as 1. If ρ_max ≠ 0 and ρ_min = 0 then all partial derivatives along one axis are zero, the fragment’s footprint in texel space is a line segment, and η should be treated as max_Aniso. However, anytime the footprint is small in texel space the implementation may use a smaller value of η, even when ρ_min is zero or close to zero. If either VkPhysicalDeviceFeatures::samplerAnisotropy or VkSamplerCreateInfo::anisotropyEnable are VK_FALSE, max_Aniso is set to 1.

If η = 1, sampling is isotropic. If η > 1, sampling is anisotropic.

The sampling rate (N) is derived as:

: N = ⌈η⌉

An implementation may round N up to the nearest supported sampling rate. An implementation may use the value of N as an approximation of η.

Level-of-Detail Operation

The LOD parameter λ is computed as follows:

\[\begin{aligned} \lambda_{base}(x,y) & = \begin{cases} shaderOp.Lod & \text{(from optional SPIR-V operand)} \\ \log_2 \left ( \frac{\rho_{max}}{\eta} \right ) & \text{otherwise} \end{cases} \\ \lambda'(x,y) & = \lambda_{base} + \mathbin{clamp}(sampler.bias + shaderOp.bias,-maxSamplerLodBias,maxSamplerLodBias) \\ \lambda & = \begin{cases} lod_{max}, & \lambda' > lod_{max} \\ \lambda', & lod_{min} \leq \lambda' \leq lod_{max} \\ lod_{min}, & \lambda' < lod_{min} \\ \textit{undefined}, & lod_{min} > lod_{max} \end{cases} \end{aligned}\]

where:

\[\begin{aligned} sampler.bias & = mipLodBias & \text{(from sampler descriptor)} \\ shaderOp.bias & = \begin{cases} Bias & \text{(from optional SPIR-V operand)} \\ 0 & \text{otherwise} \end{cases} \\ sampler.lod_{min} & = minLod & \text{(from sampler descriptor)} \\ shaderOp.lod_{min} & = \begin{cases} MinLod & \text{(from optional SPIR-V operand)} \\ 0 & \text{otherwise} \end{cases} \\ \\ lod_{min} & = \max(sampler.lod_{min}, shaderOp.lod_{min}) \\ lod_{max} & = maxLod & \text{(from sampler descriptor)} \end{aligned}\]

and maxSamplerLodBias is the value of the VkPhysicalDeviceLimits feature maxSamplerLodBias.

Image Level(s) Selection

The image level(s) d, d_hi, and d_lo which texels are read from are determined by an image-level parameter d_l, which is computed based on the LOD parameter, as follows:

\[\begin{aligned} d_{l} = \begin{cases} nearest(d'), & \text{mipmapMode is VK\_SAMPLER\_MIPMAP\_MODE\_NEAREST} \\ d', & \text{otherwise} \end{cases} \end{aligned}\]

where:

\[\begin{aligned} d' = level_{base} + \text{clamp}(\lambda, 0, q) \end{aligned}\]

\[\begin{aligned} nearest(d') & = \begin{cases} \left \lceil d' + 0.5\right \rceil - 1, & \text{preferred} \\ \left \lfloor d' + 0.5\right \rfloor, & \text{alternative} \end{cases} \end{aligned}\]

and:

: level_base = baseMipLevel
: q = levelCount - 1

baseMipLevel and levelCount are taken from the subresourceRange of the image view.

If the sampler’s mipmapMode is VK_SAMPLER_MIPMAP_MODE_NEAREST, then the level selected is d = d_l.

If the sampler’s mipmapMode is VK_SAMPLER_MIPMAP_MODE_LINEAR, two neighboring levels are selected:

\[\begin{aligned} d_{hi} & = \lfloor d_{l} \rfloor \\ d_{lo} & = min( d_{hi} + 1, q ) \\ \delta & = d_{l} - d_{hi} \end{aligned}\]

δ is the fractional value, quantized to the number of mipmap precision bits, used for linear filtering between levels.

15.5.8. (s,t,r,q,a) to (u,v,w,a) Transformation

The normalized texel coordinates are scaled by the image level dimensions and the array layer is selected.

This transformation is performed once for each level used in filtering (either d, or d_hi and d_lo).

\[\begin{aligned} u(x,y) & = s(x,y) \times width_{scale} + \Delta_i\\ v(x,y) & = \begin{cases} 0 & \text{for 1D images} \\ t(x,y) \times height_{scale} + \Delta_j & \text{otherwise} \end{cases} \\ w(x,y) & = \begin{cases} 0 & \text{for 2D or Cube images} \\ r(x,y) \times depth_{scale} + \Delta_k & \text{otherwise} \end{cases} \\ \\ a(x,y) & = \begin{cases} a(x,y) & \text{for array images} \\ 0 & \text{otherwise} \end{cases} \end{aligned}\]

where:

: width_scale = width_level
: height_scale = height_level
: depth_scale = depth_level

for conventional images, and:

: width_scale = width_level - 1
: height_scale = height_level - 1
: depth_scale = depth_level - 1

for corner-sampled images.

and where (Δ_i, Δ_j, Δ_k) are taken from the image instruction if it includes a ConstOffset or Offset operand, otherwise they are taken to be zero.

Operations then proceed to Unnormalized Texel Coordinate Operations.

15.6. Unnormalized Texel Coordinate Operations

15.6.1. (u,v,w,a) to (i,j,k,l,n) Transformation And Array Layer Selection

The unnormalized texel coordinates are transformed to integer texel coordinates relative to the selected mipmap level.

The layer index l is computed as:

: l = clamp(RNE(a), 0, layerCount - 1) + baseArrayLayer

where layerCount is the number of layers in the image subresource range of the image view, baseArrayLayer is the first layer from the subresource range, and where:

\[\begin{aligned} \mathbin{RNE}(a) & = \begin{cases} \mathbin{roundTiesToEven}(a) & \text{preferred, from IEEE Std 754-2008 Floating-Point Arithmetic} \\ \left \lfloor a + 0.5 \right \rfloor & \text{alternative} \end{cases} \end{aligned}\]

The sample index n is assigned the value zero.

Nearest filtering (VK_FILTER_NEAREST) computes the integer texel coordinates that the unnormalized coordinates lie within:

\[\begin{aligned} i &= \lfloor u + shift \rfloor \\ j &= \lfloor v + shift \rfloor \\ k &= \lfloor w + shift \rfloor \end{aligned}\]

where:

: shift = 0.0

for conventional images, and:

: shift = 0.5

for corner-sampled images.

Linear filtering (VK_FILTER_LINEAR) computes a set of neighboring coordinates which bound the unnormalized coordinates. The integer texel coordinates are combinations of i₀ or i₁, j₀ or j₁, k₀ or k₁, as well as weights α, β, and γ.

\[\begin{aligned} i_0 &= \lfloor u - shift \rfloor \\ i_1 &= i_0 + 1 \\ j_0 &= \lfloor v - shift \rfloor \\ j_1 &= j_0 + 1 \\ k_0 &= \lfloor w - shift \rfloor k_1 &= k_0 + 1 \end{aligned}\]

\[\begin{aligned} \alpha &= \mathbin{frac}\left(u - shift\right) \\[1em] \beta &= \mathbin{frac}\left(v - shift\right) \\[1em] \gamma &= \mathbin{frac}\left(w - shift\right) \end{aligned}\]

where:

: shift = 0.5

for conventional images, and:

: shift = 0.0

for corner-sampled images, and where:

\[\mathbin{frac}(x) = x - \lfloor x \rfloor\]

where the number of fraction bits retained is specified by VkPhysicalDeviceLimits::subTexelPrecisionBits.

Cubic filtering (VK_FILTER_CUBIC_EXT) computes a set of neighboring coordinates which bound the unnormalized coordinates. The integer texel coordinates are combinations of i₀, i₁, i₂ or i₃, j₀, j₁, j₂ or j₃, k₀, k₁, k₂ or k₃, as well as weights α, β, and γ.

\[\begin{aligned} i_{0} & = {\left \lfloor {u - \frac{3}{2}} \right \rfloor} & i_{1} & = i_{0} + 1 & i_{2} & = i_{1} + 1 & i_{3} & = i_{2} + 1 \\[1em] j_{0} & = {\left \lfloor {v - \frac{3}{2}} \right \rfloor} & j_{1} & = j_{0} + 1 & j_{2} & = j_{1} + 1 & j_{3} & = j_{2} + 1 \\[1em] k_{0} & = {\left \lfloor {w - \frac{3}{2}} \right \rfloor} & k_{1} & = k_{0} + 1 & k_{2} & = k_{1} + 1 & k_{3} & = k_{2} + 1 \end{aligned}\]

\[\begin{aligned} \alpha &= \mathbin{frac}\left(u - \frac{1}{2}\right) \\[1em] \beta &= \mathbin{frac}\left(v - \frac{1}{2}\right) \\[1em] \gamma &= \mathbin{frac}\left(w - \frac{1}{2}\right) \end{aligned}\]

where:

\[\mathbin{frac}(x) = x - \lfloor x \rfloor\]

where the number of fraction bits retained is specified by VkPhysicalDeviceLimits::subTexelPrecisionBits.

15.7. Integer Texel Coordinate Operations

Integer texel coordinate operations may supply a LOD which texels are to be read from or written to using the optional SPIR-V operand Lod. If the Lod is provided then it must be an integer.

The image level selected is:

\[\begin{aligned} d & = level_{base} + \begin{cases} Lod & \text{(from optional SPIR-V operand)} \\ 0 & \text{otherwise} \end{cases} \\ \end{aligned}\]

If d does not lie in the range [baseMipLevel, baseMipLevel + levelCount) then any values fetched are undefined, and any writes are discarded.

15.8. Image Sample Operations

15.8.1. Wrapping Operation

Cube images ignore the wrap modes specified in the sampler. Instead, if VK_FILTER_NEAREST is used within a mip level then VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE is used, and if VK_FILTER_LINEAR is used within a mip level then sampling at the edges is performed as described earlier in the Cube map edge handling section.

The first integer texel coordinate i is transformed based on the addressModeU parameter of the sampler.

\[\begin{aligned} i &= \begin{cases} i \bmod size & \text{for repeat} \\ (size - 1) - \mathbin{mirror} ((i \bmod (2 \times size)) - size) & \text{for mirrored repeat} \\ \mathbin{clamp}(i,0,size-1) & \text{for clamp to edge} \\ \mathbin{clamp}(i,-1,size) & \text{for clamp to border} \\ \mathbin{clamp}(\mathbin{mirror}(i),0,size-1) & \text{for mirror clamp to edge} \end{cases} \end{aligned}\]

where:

\[\begin{aligned} & \mathbin{mirror}(n) = \begin{cases} n & \text{for}\ n \geq 0 \\ -(1+n) & \text{otherwise} \end{cases} \end{aligned}\]

j (for 2D and Cube image) and k (for 3D image) are similarly transformed based on the addressModeV and addressModeW parameters of the sampler, respectively.

15.8.2. Texel Gathering

SPIR-V instructions with Gather in the name return a vector derived from 4 texels in the base level of the image view. The rules for the VK_FILTER_LINEAR minification filter are applied to identify the four selected texels. Each texel is then converted to an RGBA value according to conversion to RGBA and then swizzled. A four-component vector is then assembled by taking the component indicated by the Component value in the instruction from the swizzled color value of the four texels. If the operation does not use the ConstOffsets image operand then the four texels form the 2 × 2 rectangle used for texture filtering:

\[\begin{aligned} \tau[R] &= \tau_{i0j1}[level_{base}][comp] \\ \tau[G] &= \tau_{i1j1}[level_{base}][comp] \\ \tau[B] &= \tau_{i1j0}[level_{base}][comp] \\ \tau[A] &= \tau_{i0j0}[level_{base}][comp] \end{aligned}\]

If the operation does use the ConstOffsets image operand then the offsets allow a custom filter to be defined:

\[\begin{aligned} \tau[R] &= \tau_{i0j0 + \Delta_0}[level_{base}][comp] \\ \tau[G] &= \tau_{i0j0 + \Delta_1}[level_{base}][comp] \\ \tau[B] &= \tau_{i0j0 + \Delta_2}[level_{base}][comp] \\ \tau[A] &= \tau_{i0j0 + \Delta_3}[level_{base}][comp] \end{aligned}\]

where:

\[\begin{aligned} \tau[level_{base}][comp] &= \begin{cases} \tau[level_{base}][R], & \text{for}\ comp = 0 \\ \tau[level_{base}][G], & \text{for}\ comp = 1 \\ \tau[level_{base}][B], & \text{for}\ comp = 2 \\ \tau[level_{base}][A], & \text{for}\ comp = 3 \end{cases}\\ comp & \,\text{from SPIR-V operand Component} \end{aligned}\]

OpImage*Gather must not be used on a sampled image with sampler Y′C_BC_R conversion enabled.

15.8.3. Texel Filtering

Texel filtering is first performed for each level (either d or d_hi and d_lo).

If λ is less than or equal to zero, the texture is said to be magnified, and the filter mode within a mip level is selected by the magFilter in the sampler. If λ is greater than zero, the texture is said to be minified, and the filter mode within a mip level is selected by the minFilter in the sampler.

Texel Nearest Filtering

Within a mip level, VK_FILTER_NEAREST filtering selects a single value using the (i, j, k) texel coordinates, with all texels taken from layer l.

\[\begin{aligned} \tau[level] &= \begin{cases} \tau_{ijk}[level], & \text{for 3D image} \\ \tau_{ij}[level], & \text{for 2D or Cube image} \\ \tau_{i}[level], & \text{for 1D image} \end{cases} \end{aligned}\]

Texel Linear Filtering

Within a mip level, VK_FILTER_LINEAR filtering combines 8 (for 3D), 4 (for 2D or Cube), or 2 (for 1D) texel values, together with their linear weights. The linear weights are derived from the fractions computed earlier:

\[\begin{aligned} w_{i_0} &= (1-\alpha) \\ w_{i_1} &= (\alpha) \\ w_{j_0} &= (1-\beta) \\ w_{j_1} &= (\beta) \\ w_{k_0} &= (1-\gamma) \\ w_{k_1} &= (\gamma) \end{aligned}\]

The values of multiple texels, together with their weights, are combined to produce a filtered value.

The VkSamplerReductionModeCreateInfo::reductionMode can control the process by which multiple texels, together with their weights, are combined to produce a filtered texture value.

When the reductionMode is set (explicitly or implicitly) to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, a weighted average is computed:

\[\begin{aligned} \tau_{3D} &= \sum_{k=k_0}^{k_1}\sum_{j=j_0}^{j_1}\sum_{i=i_0}^{i_1}(w_{i})(w_{j})(w_{k})\tau_{ijk} \\ \tau_{2D} &= \sum_{j=j_0}^{j_1}\sum_{i=i_0}^{i_1}(w_{i})(w_{j})\tau_{ij} \\ \tau_{1D} &= \sum_{i=i_0}^{i_1}(w_{i})\tau_{i} \end{aligned}\]

However, if the reduction mode is VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX, the process operates on the above set of multiple texels, together with their weights, computing a component-wise minimum or maximum, respectively, of the components of the set of texels with non-zero weights.

Texel Cubic Filtering

Within a mip level, VK_FILTER_CUBIC_EXT, filtering computes a weighted average of 64 (for 3D), 16 (for 2D), or 4 (for 1D) texel values, together with their Catmull-Rom weights.

Catmull-Rom weights are derived from the fractions computed earlier.

\[\begin{aligned} \begin{bmatrix} w_{i_0}\phantom{,} w_{i_1}\phantom{,} w_{i_2}\phantom{,} w_{i_3} \end{bmatrix} = \frac{1}{2} \begin{bmatrix} 1 & \alpha & \alpha^2 & \alpha^3 \end{bmatrix} \begin{bmatrix} \phantom{-}0 & \phantom{-}2 & \phantom{-}0 & \phantom{-}0 \\ -1 & \phantom{-}0 & \phantom{-}1 & \phantom{-}0 \\ \phantom{-}2 & -5 & \phantom{-}4 & -1 \\ -1 & \phantom{-}3 & -3 & \phantom{-}1 \end{bmatrix} \\ \begin{bmatrix} w_{j_0}\phantom{,} w_{j_1}\phantom{,} w_{j_2}\phantom{,} w_{j_3} \end{bmatrix} = \frac{1}{2} \begin{bmatrix} 1 & \beta & \beta^2 & \beta^3 \end{bmatrix} \begin{bmatrix} \phantom{-}0 & \phantom{-}2 & \phantom{-}0 & \phantom{-}0 \\ -1 & \phantom{-}0 & \phantom{-}1 & \phantom{-}0 \\ \phantom{-}2 & -5 & \phantom{-}4 & -1 \\ -1 & \phantom{-}3 & -3 & \phantom{-}1 \end{bmatrix} \\ \begin{bmatrix} w_{k_0}\phantom{,} w_{k_1}\phantom{,} w_{k_2}\phantom{,} w_{k_3} \end{bmatrix} = \frac{1}{2} \begin{bmatrix} 1 & \gamma & \gamma^2 & \gamma^3 \end{bmatrix} \begin{bmatrix} \phantom{-}0 & \phantom{-}2 & \phantom{-}0 & \phantom{-}0 \\ -1 & \phantom{-}0 & \phantom{-}1 & \phantom{-}0 \\ \phantom{-}2 & -5 & \phantom{-}4 & -1 \\ -1 & \phantom{-}3 & -3 & \phantom{-}1 \end{bmatrix} \end{aligned}\]

The values of multiple texels, together with their weights, are combined to produce a filtered value.

The VkSamplerReductionModeCreateInfo::reductionMode can control the process by which multiple texels, together with their weights, are combined to produce a filtered texture value.

When the reductionMode is set (explicitly or implicitly) to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, a weighted average is computed:

\[\begin{aligned} \tau_{3D} &= \sum_{k=j_0}^{k_3}\sum_{j=j_0}^{j_3}\sum_{i=i_0}^{i_3}(w_{i})(w_{j})(w_{k})\tau_{ijk} \\ \tau_{2D} &= \sum_{j=j_0}^{j_3}\sum_{i=i_0}^{i_3}(w_{i})(w_{j})\tau_{ij} \\ \tau_{1D} &= \sum_{i=i_0}^{i_3}(w_{i})\tau_{i} \end{aligned}\]

Texel Mipmap Filtering

VK_SAMPLER_MIPMAP_MODE_NEAREST filtering returns the value of a single mipmap level,

τ = τ[d].

VK_SAMPLER_MIPMAP_MODE_LINEAR filtering combines the values of multiple mipmap levels (τ[hi] and τ[lo]), together with their linear weights.

The linear weights are derived from the fraction computed earlier:

\[\begin{aligned} w_{hi} &= (1-\delta) \\ w_{lo} &= (\delta) \\ \end{aligned}\]

The values of multiple mipmap levels, together with their weights, are combined to produce a final filtered value.

The VkSamplerReductionModeCreateInfo::reductionMode can control the process by which multiple texels, together with their weights, are combined to produce a filtered texture value.

When the reductionMode is set (explicitly or implicitly) to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, a weighted average is computed:

\[\begin{aligned} \tau &= (w_{hi})\tau[hi]+(w_{lo})\tau[lo] \end{aligned}\]

Texel Anisotropic Filtering

Anisotropic filtering is enabled by the anisotropyEnable in the sampler. When enabled, the image filtering scheme accounts for a degree of anisotropy.

The particular scheme for anisotropic texture filtering is implementation dependent. Implementations should consider the magFilter, minFilter and mipmapMode of the sampler to control the specifics of the anisotropic filtering scheme used. In addition, implementations should consider minLod and maxLod of the sampler.

The following describes one particular approach to implementing anisotropic filtering for the 2D Image case, implementations may choose other methods:

Given a magFilter, minFilter of VK_FILTER_LINEAR and a mipmapMode of VK_SAMPLER_MIPMAP_MODE_NEAREST:

Instead of a single isotropic sample, N isotropic samples are be sampled within the image footprint of the image level d to approximate an anisotropic filter. The sum τ_2Daniso is defined using the single isotropic τ_2D(u,v) at level d.

\[\begin{aligned} \tau_{2Daniso} & = \frac{1}{N}\sum_{i=1}^{N} {\tau_{2D}\left ( u \left ( x - \frac{1}{2} + \frac{i}{N+1} , y \right ), \left ( v \left (x-\frac{1}{2}+\frac{i}{N+1} \right ), y \right ) \right )}, & \text{when}\ \rho_{x} > \rho_{y} \\ \tau_{2Daniso} &= \frac{1}{N}\sum_{i=1}^{N} {\tau_{2D}\left ( u \left ( x, y - \frac{1}{2} + \frac{i}{N+1} \right ), \left ( v \left (x,y-\frac{1}{2}+\frac{i}{N+1} \right ) \right ) \right )}, & \text{when}\ \rho_{y} \geq \rho_{x} \end{aligned}\]

When VkSamplerReductionModeCreateInfo::reductionMode is set to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, the above summation is used. However, if the reduction mode is VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX, the process operates on the above values, together with their weights, computing a component-wise minimum or maximum, respectively, of the components of the values with non-zero weights.

15.9. Texel Footprint Evaluation

The SPIR-V instruction OpImageSampleFootprintNV evaluates the set of texels from a single mip level that would be accessed during a texel filtering operation. In addition to the inputs that would be accepted by an equivalent OpImageSample* instruction, OpImageSampleFootprintNV accepts two additional inputs. The Granularity input is an integer identifying the size of texel groups used to evaluate the footprint. Each bit in the returned footprint mask corresponds to an aligned block of texels whose size is given by the following table:

Table 27. Texel footprint granularity values
`Granularity`	`Dim` = 2D	`Dim` = 3D
0	unsupported	unsupported
1	2x2	2x2x2
2	4x2	unsupported
3	4x4	4x4x2
4	8x4	unsupported
5	8x8	unsupported
6	16x8	unsupported
7	16x16	unsupported
8	unsupported	unsupported
9	unsupported	unsupported
10	unsupported	16x16x16
11	64x64	32x16x16
12	128x64	32x32x16
13	128x128	32x32x32
14	256x128	64x32x32
15	256x256	unsupported

The Coarse input is used to select between the two mip levels that may be accessed during texel filtering when using a mipmapMode of VK_SAMPLER_MIPMAP_MODE_LINEAR. When filtering between two mip levels, a Coarse value of true requests the footprint in the lower-resolution mip level (higher level number), while false requests the footprint in the higher-resolution mip level. If texel filtering would access only a single mip level, the footprint in that level would be returned when Coarse is set to false; an empty footprint would be returned when Coarse is set to true.

The footprint for OpImageSampleFootprintNV is returned in a structure with six members:

The first member is a boolean value that is true if the texel filtering operation would access only a single mip level.
The second member is a two- or three-component integer vector holding the footprint anchor location. For two-dimensional images, the returned components are in units of eight texel groups. For three-dimensional images, the returned components are in units of four texel groups.
The third member is a two- or three-component integer vector holding a footprint offset relative to the anchor. All returned components are in units of texel groups.
The fourth member is a two-component integer vector mask, which holds a bitfield identifying the set of texel groups in an 8x8 or 4x4x4 neighborhood relative to the anchor and offset.
The fifth member is an integer identifying the mip level containing the footprint identified by the anchor, offset, and mask.
The sixth member is an integer identifying the granularity of the returned footprint.

For footprints in two-dimensional images (Dim2D), the mask returned by OpImageSampleFootprintNV indicates whether each texel group in a 8x8 local neighborhood of texel groups would have one or more texels accessed during texel filtering. In the mask, the texel group with local group coordinates \((lgx,lgy)\) is considered covered if and only if

\[\begin{aligned} 0 \neq ((mask.x + (mask.y << 32)) \text{ \& } (1 << (lgy \times 8 + lgx))) \end{aligned}\]

where:

\(0<=lgx<8\) and \(0<=lgy<8\); and
\(mask\) is the returned two-component mask.

The local group with coordinates \((lgx,lgy)\) in the mask is considered covered if and only if the texel filtering operation would access one or more texels \(\tau_{ij}\) in the returned miplevel where:

\[\begin{aligned} i0 & = \begin{cases} gran.x \times (8 \times anchor.x + lgx), & \text{if } lgx + offset.x < 8 \\ gran.x \times (8 \times (anchor.x - 1) + lgx), & \text{otherwise} \end{cases} \\ i1 & = i0 + gran.x - 1 \\ j0 & = \begin{cases} gran.y \times (8 \times anchor.y + lgy), & \text{if } lgy + offset.y < 8 \\ gran.y \times (8 \times (anchor.y - 1) + lgy), & otherwise \end{cases} \\ j1 & = j0 + gran.y - 1 \end{aligned}\]

and

\(i0<=i<=i1\) and \(j0<=j<=j1\);
\(gran\) is a two-component vector holding the width and height of the texel group identified by the granularity;
\(anchor\) is the returned two-component anchor vector; and
\(offset\) is the returned two-component offset vector.

For footprints in three-dimensional images (Dim3D), the mask returned by OpImageSampleFootprintNV indicates whether each texel group in a 4x4x4 local neighborhood of texel groups would have one or more texels accessed during texel filtering. In the mask, the texel group with local group coordinates \((lgx,lgy,lgz)\), is considered covered if and only if:

\[\begin{aligned} 0 \neq ((mask.x + (mask.y << 32)) \text{ \& } (1 << (lgz \times 16 + lgy \times 4 + lgx))) \end{aligned}\]

where:

\(0<=lgx<4\), \(0<=lgy<4\), and \(0<=lgz<4\); and
\(mask\) is the returned two-component mask.

The local group with coordinates \((lgx,lgy,lgz)\) in the mask is considered covered if and only if the texel filtering operation would access one or more texels \(\tau_{ijk}\) in the returned miplevel where:

\[\begin{aligned} i0 & = \begin{cases} gran.x \times (4 \times anchor.x + lgx), & \text{if } lgx + offset.x < 4 \\ gran.x \times (4 \times (anchor.x - 1) + lgx), & \text{otherwise} \end{cases} \\ i1 & = i0 + gran.x - 1 \\ j0 & = \begin{cases} gran.y \times (4 \times anchor.y + lgy), & \text{if } lgy + offset.y < 4 \\ gran.y \times (4 \times (anchor.y - 1) + lgy), & otherwise \end{cases} \\ j1 & = j0 + gran.y - 1 \\ k0 & = \begin{cases} gran.z \times (4 \times anchor.z + lgz), & \text{if } lgz + offset.z < 4 \\ gran.z \times (4 \times (anchor.z - 1) + lgz), & otherwise \end{cases} \\ k1 & = k0 + gran.z - 1 \end{aligned}\]

and

\(i0<=i<=i1\), \(j0<=j<=j1\), \(k0<=k<=k1\);
\(gran\) is a three-component vector holding the width, height, and depth of the texel group identified by the granularity;
\(anchor\) is the returned three-component anchor vector; and
\(offset\) is the returned three-component offset vector.

If the sampler used by OpImageSampleFootprintNV enables anisotropic texel filtering via anisotropyEnable, it is possible that the set of texel groups accessed in a mip level may be too large to be expressed using an 8x8 or 4x4x4 mask using the granularity requested in the instruction. In this case, the implementation uses a texel group larger than the requested granularity. When a larger texel group size is used, OpImageSampleFootprintNV returns an integer granularity value that can be interpreted in the same manner as the granularity value provided to the instruction to determine the texel group size used. If anisotropic texel filtering is disabled in the sampler, or if an anisotropic footprint can be represented as an 8x8 or 4x4x4 mask with the requested granularity, OpImageSampleFootprintNV will use the requested granularity as-is and return a granularity value of zero.

OpImageSampleFootprintNV supports only two- and three-dimensional image accesses (Dim2D and Dim3D) and the footprint returned is undefined if a sampler uses an addressing mode other than VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.

15.10. Image Operation Steps

Each step described in this chapter is performed by a subset of the image instructions:

Texel Input Validation Operations, Format Conversion, Texel Replacement, Conversion to RGBA, and Component Swizzle: Performed by all instructions except OpImageWrite.
Depth Comparison: Performed by OpImage*Dref instructions.
All Texel output operations: Performed by OpImageWrite.
Projection: Performed by all OpImage*Proj instructions.
Derivative Image Operations, Cube Map Operations, Scale Factor Operation, Level-of-Detail Operation and Image Level(s) Selection, and Texel Anisotropic Filtering: Performed by all OpImageSample* and OpImageSparseSample* instructions.
(s,t,r,q,a) to (u,v,w,a) Transformation, Wrapping, and (u,v,w,a) to (i,j,k,l,n) Transformation And Array Layer Selection: Performed by all OpImageSample, OpImageSparseSample, and OpImage*Gather instructions.
Texel Gathering: Performed by OpImage*Gather instructions.
Texel Footprint Evaluation: Performed by OpImageSampleFootprint instructions.
Texel Filtering: Performed by all OpImageSample* and OpImageSparseSample* instructions.
Sparse Residency: Performed by all OpImageSparse* instructions.

16. Fragment Density Map Operations

16.1. Fragment Density Map Operations Overview

When a fragment is generated in a render pass that has a fragment density map attachment, its area is determined by the properties of the local framebuffer region that the fragment occupies. The framebuffer is divided into a uniform grid of these local regions, and their fragment area property is derived from the density map with the following operations:

Fetch density value
- Component swizzle
- Component mapping
Fragment area conversion
- Fragment area filter
- Fragment area clamp

16.2. Fetch Density Value

Each local framebuffer region at center coordinate (x,y) fetches a texel from the fragment density map at integer coordinates:

: \(i = \lfloor{\frac{x}{fragmentDensityTexelSize_{width}}}\rfloor\)
: \(j = \lfloor{\frac{y}{fragmentDensityTexelSize_{height}}}\rfloor\)

Where the size of each region in the framebuffer is:

: \(fragmentDensityTexelSize'_{width} = {2^{\lceil{\log_2(\frac{framebuffer_{width}}{fragmentDensityMap_{width}})}\rceil}}\)
: \(fragmentDensityTexelSize'_{height} = {2^{\lceil{\log_2(\frac{framebuffer_{height}}{fragmentDensityMap_{height}})}\rceil}}\)

This region is subject to the limits in VkPhysicalDeviceFragmentDensityMapPropertiesEXT and therefore the final region size is clamped:

: \(fragmentDensityTexelSize_{width} = \mathbin{clamp}(fragmentDensityTexelSize'_{width},minFragmentDensityTexelSize_{width},maxFragmentDensityTexelSize_{width})\)
: \(fragmentDensityTexelSize_{height} = \mathbin{clamp}(fragmentDensityTexelSize'_{height},minFragmentDensityTexelSize_{height},maxFragmentDensityTexelSize_{height})\)

When multiview is enabled for the render pass and the fragment density map attachment view was created with layerCount greater than 1, the density map layer that the texel is fetched from is:

: \(layer = baseArrayLayer + ViewIndex\)

Otherwise:

: \(layer = baseArrayLayer\)

The texel fetched from the density map at (i,j,layer) is next converted to density with the following operations.

16.2.1. Component Swizzle

The components member of VkImageViewCreateInfo is applied to the fetched texel as defined in Image component swizzle.

16.2.2. Component Mapping

The swizzled texel’s components are mapped to a density value:

: \(densityValue_{xy} = (C'_{r},C'_{g})\)

16.3. Fragment Area Conversion

Fragment area for the framebuffer region is undefined if the density fetched is not a normalized floating-point value greater than 0.0. Otherwise, the fetched fragment area for that region is derived as:

: \(fragmentArea_{wh} = \frac{1.0}{densityValue_{xy}}\)

16.3.1. Fragment Area Filter

Optionally, the implementation may fetch additional density map texels in an implementation defined window around (i,j). The texels follow the standard conversion steps up to and including fragment area conversion.

A single fetched fragment area for the framebuffer region is chosen by the implementation and must have an area between the min and max areas of the fetched set.

16.3.2. Fragment Area Clamp

The implementation may clamp the fetched fragment area to one that it supports. The clamped fragment area must have a size less than or equal to the original fetched value. Implementations may vary the supported set of fragment areas per framebuffer region. Fragment area (1,1) must always be in the supported set.

Note

For example, if the fetched fragment area is (1,4) but the implementation only supports areas of {(1,1),(2,2)}, it could choose to clamp the area to (2,2) since it has the same size as (1,4). While this would produce fragments that have lower quality strictly in the x-axis, the overall density is maintained.

The clamped fragment area is assigned to the corresponding framebuffer region.

17. Queries

Queries provide a mechanism to return information about the processing of a sequence of Vulkan commands. Query operations are asynchronous, and as such, their results are not returned immediately. Instead, their results, and their availability status are stored in a Query Pool. The state of these queries can be read back on the host, or copied to a buffer object on the device.

The supported query types are Occlusion Queries, Pipeline Statistics Queries, and Timestamp Queries. Performance Queries are also supported if the associated extension is available. Intel performance queries are also supported if the associated extension is available.

17.1. Query Pools

Queries are managed using query pool objects. Each query pool is a collection of a specific number of queries of a particular type.

Query pools are represented by VkQueryPool handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)

To create a query pool, call:

VkResult vkCreateQueryPool(
    VkDevice                                    device,
    const VkQueryPoolCreateInfo*                pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkQueryPool*                                pQueryPool);

device is the logical device that creates the query pool.
pCreateInfo is a pointer to a VkQueryPoolCreateInfo structure containing the number and type of queries to be managed by the pool.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pQueryPool is a pointer to a VkQueryPool handle in which the resulting query pool object is returned.

Valid Usage (Implicit)

VUID-vkCreateQueryPool-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateQueryPool-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkQueryPoolCreateInfo structure
VUID-vkCreateQueryPool-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateQueryPool-pQueryPool-parameter
pQueryPool must be a valid pointer to a VkQueryPool handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkQueryPoolCreateInfo structure is defined as:

typedef struct VkQueryPoolCreateInfo {
    VkStructureType                  sType;
    const void*                      pNext;
    VkQueryPoolCreateFlags           flags;
    VkQueryType                      queryType;
    uint32_t                         queryCount;
    VkQueryPipelineStatisticFlags    pipelineStatistics;
} VkQueryPoolCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
queryType is a VkQueryType value specifying the type of queries managed by the pool.
queryCount is the number of queries managed by the pool.
pipelineStatistics is a bitmask of VkQueryPipelineStatisticFlagBits specifying which counters will be returned in queries on the new pool, as described below in Pipeline Statistics Queries.

pipelineStatistics is ignored if queryType is not VK_QUERY_TYPE_PIPELINE_STATISTICS.

Valid Usage

VUID-VkQueryPoolCreateInfo-queryType-00791
If the pipeline statistics queries feature is not enabled, queryType must not be VK_QUERY_TYPE_PIPELINE_STATISTICS
VUID-VkQueryPoolCreateInfo-queryType-00792
If queryType is VK_QUERY_TYPE_PIPELINE_STATISTICS, pipelineStatistics must be a valid combination of VkQueryPipelineStatisticFlagBits values
VUID-VkQueryPoolCreateInfo-queryType-03222
If queryType is VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the pNext chain must include a structure of type VkQueryPoolPerformanceCreateInfoKHR
VUID-VkQueryPoolCreateInfo-queryCount-02763
queryCount must be greater than 0

Valid Usage (Implicit)

VUID-VkQueryPoolCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
VUID-VkQueryPoolCreateInfo-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkQueryPoolPerformanceCreateInfoKHR
VUID-VkQueryPoolCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkQueryPoolCreateInfo-flags-zerobitmask
flags must be 0
VUID-VkQueryPoolCreateInfo-queryType-parameter
queryType must be a valid VkQueryType value

typedef VkFlags VkQueryPoolCreateFlags;

VkQueryPoolCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

The VkQueryPoolPerformanceCreateInfoKHR structure is defined as:

typedef struct VkQueryPoolPerformanceCreateInfoKHR {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           queueFamilyIndex;
    uint32_t           counterIndexCount;
    const uint32_t*    pCounterIndices;
} VkQueryPoolPerformanceCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
queueFamilyIndex is the queue family index to create this performance query pool for.
counterIndexCount is size of the pCounterIndices array.
pCounterIndices is the array of indices into the vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR::pCounters to enable in this performance query pool.

Valid Usage

VUID-VkQueryPoolPerformanceCreateInfoKHR-queueFamilyIndex-03236
queueFamilyIndex must be a valid queue family index of the device
VUID-VkQueryPoolPerformanceCreateInfoKHR-performanceCounterQueryPools-03237
The performanceCounterQueryPools feature must be enabled
VUID-VkQueryPoolPerformanceCreateInfoKHR-pCounterIndices-03321
Each element of pCounterIndices must be in the range of counters reported by vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR for the queue family specified in queueFamilyIndex

Valid Usage (Implicit)

VUID-VkQueryPoolPerformanceCreateInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR
VUID-VkQueryPoolPerformanceCreateInfoKHR-pCounterIndices-parameter
pCounterIndices must be a valid pointer to an array of counterIndexCount uint32_t values
VUID-VkQueryPoolPerformanceCreateInfoKHR-counterIndexCount-arraylength
counterIndexCount must be greater than 0

To query the number of passes required to query a performance query pool on a physical device, call:

void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
    VkPhysicalDevice                            physicalDevice,
    const VkQueryPoolPerformanceCreateInfoKHR*  pPerformanceQueryCreateInfo,
    uint32_t*                                   pNumPasses);

physicalDevice is the handle to the physical device whose queue family performance query counter properties will be queried.
pPerformanceQueryCreateInfo is a pointer to a VkQueryPoolPerformanceCreateInfoKHR of the performance query that is to be created.
pNumPasses is a pointer to an integer related to the number of passes required to query the performance query pool, as described below.

The pPerformanceQueryCreateInfo member VkQueryPoolPerformanceCreateInfoKHR::queueFamilyIndex must be a queue family of physicalDevice. The number of passes required to capture the counters specified in the pPerformanceQueryCreateInfo member VkQueryPoolPerformanceCreateInfoKHR::pCounters is returned in pNumPasses.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR-pPerformanceQueryCreateInfo-parameter
pPerformanceQueryCreateInfo must be a valid pointer to a valid VkQueryPoolPerformanceCreateInfoKHR structure
VUID-vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR-pNumPasses-parameter
pNumPasses must be a valid pointer to a uint32_t value

To destroy a query pool, call:

void vkDestroyQueryPool(
    VkDevice                                    device,
    VkQueryPool                                 queryPool,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the query pool.
queryPool is the query pool to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyQueryPool-queryPool-00793
All submitted commands that refer to queryPool must have completed execution
VUID-vkDestroyQueryPool-queryPool-00794
If VkAllocationCallbacks were provided when queryPool was created, a compatible set of callbacks must be provided here
VUID-vkDestroyQueryPool-queryPool-00795
If no VkAllocationCallbacks were provided when queryPool was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyQueryPool-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyQueryPool-queryPool-parameter
If queryPool is not VK_NULL_HANDLE, queryPool must be a valid VkQueryPool handle
VUID-vkDestroyQueryPool-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyQueryPool-queryPool-parent
If queryPool is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to queryPool must be externally synchronized

Possible values of VkQueryPoolCreateInfo::queryType, specifying the type of queries managed by the pool, are:

typedef enum VkQueryType {
    VK_QUERY_TYPE_OCCLUSION = 0,
    VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
    VK_QUERY_TYPE_TIMESTAMP = 2,
    VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004,
    VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000,
    VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000,
    VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000,
    VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkQueryType;

VK_QUERY_TYPE_OCCLUSION specifies an occlusion query.
VK_QUERY_TYPE_PIPELINE_STATISTICS specifies a pipeline statistics query.
VK_QUERY_TYPE_TIMESTAMP specifies a timestamp query.
VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR specifies a performance query.
VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT specifies a transform feedback query.
VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV specifies a ray tracing acceleration structure size query.
VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL specifies a Intel performance query.

17.2. Query Operation

The operation of queries is controlled by the commands vkCmdBeginQuery, vkCmdEndQuery, vkCmdBeginQueryIndexedEXT, vkCmdEndQueryIndexedEXT, vkCmdResetQueryPool, vkCmdCopyQueryPoolResults, and vkCmdWriteTimestamp.

In order for a VkCommandBuffer to record query management commands, the queue family for which its VkCommandPool was created must support the appropriate type of operations (graphics, compute) suitable for the query type of a given query pool.

Each query in a query pool has a status that is either unavailable or available, and also has state to store the numerical results of a query operation of the type requested when the query pool was created. Resetting a query via vkCmdResetQueryPool or vkResetQueryPool sets the status to unavailable and makes the numerical results undefined. Performing a query operation with vkCmdBeginQuery and vkCmdEndQuery changes the status to available when the query finishes, and updates the numerical results. Both the availability status and numerical results are retrieved by calling either vkGetQueryPoolResults or vkCmdCopyQueryPoolResults.

Query commands, for the same query and submitted to the same queue, execute in their entirety in submission order, relative to each other. In effect there is an implicit execution dependency from each such query command to all query command previously submitted to the same queue. There is one significant exception to this; if the flags parameter of vkCmdCopyQueryPoolResults does not include VK_QUERY_RESULT_WAIT_BIT, execution of vkCmdCopyQueryPoolResults may happen-before the results of vkCmdEndQuery are available.

After query pool creation, each query must be reset before it is used. Queries must also be reset between uses.

If a logical device includes multiple physical devices, then each command that writes a query must execute on a single physical device, and any call to vkCmdBeginQuery must execute the corresponding vkCmdEndQuery command on the same physical device.

To reset a range of queries in a query pool on a queue, call:

void vkCmdResetQueryPool(
    VkCommandBuffer                             commandBuffer,
    VkQueryPool                                 queryPool,
    uint32_t                                    firstQuery,
    uint32_t                                    queryCount);

commandBuffer is the command buffer into which this command will be recorded.
queryPool is the handle of the query pool managing the queries being reset.
firstQuery is the initial query index to reset.
queryCount is the number of queries to reset.

When executed on a queue, this command sets the status of query indices [firstQuery, firstQuery + queryCount - 1] to unavailable.

If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, this command sets the status of query indices [firstQuery, firstQuery + queryCount - 1] to unavailable for each pass of queryPool, as indicated by a call to vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.

Note

Because vkCmdResetQueryPool resets all the passes of the indicated queries, applications must not record a vkCmdResetQueryPool command for a queryPool created with VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR in a command buffer that needs to be submitted multiple times as indicated by a call to vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR. Otherwise applications will never be able to complete the recorded queries.

Valid Usage

VUID-vkCmdResetQueryPool-firstQuery-00796
firstQuery must be less than the number of queries in queryPool
VUID-vkCmdResetQueryPool-firstQuery-00797
The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool
VUID-vkCmdResetQueryPool-None-02841
All queries used by the command must not be active
VUID-vkCmdResetQueryPool-firstQuery-02862
This command must not be recorded in a command buffer that, either directly or through secondary command buffers, also contains, begin commands for a query from the set of queries [firstQuery, firstQuery + queryCount - 1]

Valid Usage (Implicit)

VUID-vkCmdResetQueryPool-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdResetQueryPool-queryPool-parameter
queryPool must be a valid VkQueryPool handle
VUID-vkCmdResetQueryPool-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdResetQueryPool-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
VUID-vkCmdResetQueryPool-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdResetQueryPool-commonparent
Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Graphics
Compute

To reset a range of queries in a query pool on the host, call:

void vkResetQueryPool(
    VkDevice                                    device,
    VkQueryPool                                 queryPool,
    uint32_t                                    firstQuery,
    uint32_t                                    queryCount);

or the equivalent command

void vkResetQueryPoolEXT(
    VkDevice                                    device,
    VkQueryPool                                 queryPool,
    uint32_t                                    firstQuery,
    uint32_t                                    queryCount);

device is the logical device that owns the query pool.
queryPool is the handle of the query pool managing the queries being reset.
firstQuery is the initial query index to reset.
queryCount is the number of queries to reset.

This command sets the status of query indices [firstQuery, firstQuery + queryCount - 1] to unavailable.

If queryPool is VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR this command sets the status of query indices [firstQuery, firstQuery + queryCount - 1] to unavailable for each pass.

Valid Usage

VUID-vkResetQueryPool-None-02665
The hostQueryReset feature must be enabled
VUID-vkResetQueryPool-firstQuery-02666
firstQuery must be less than the number of queries in queryPool
VUID-vkResetQueryPool-firstQuery-02667
The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool
VUID-vkResetQueryPool-firstQuery-02741
Submitted commands that refer to the range specified by firstQuery and queryCount in queryPool must have completed execution
VUID-vkResetQueryPool-firstQuery-02742
The range of queries specified by firstQuery and queryCount in queryPool must not be in use by calls to vkGetQueryPoolResults or vkResetQueryPool in other threads

Valid Usage (Implicit)

VUID-vkResetQueryPool-device-parameter
device must be a valid VkDevice handle
VUID-vkResetQueryPool-queryPool-parameter
queryPool must be a valid VkQueryPool handle
VUID-vkResetQueryPool-queryPool-parent
queryPool must have been created, allocated, or retrieved from device

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 vkCmdEndQuery command within a specified command buffer, effectively scoping a set of drawing and/or dispatch commands. Timestamp queries write timestamps to a query pool. Performance queries record performance counters 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 VkCommandBufferInheritanceInfo to conservative values, as described in the Command Buffer Recording section. 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 queries are used while executing a render pass instance that has multiview enabled, the query uses N consecutive query indices in the query pool (starting at query) where N is the number of bits set in the view mask in the subpass the query is used in. How the numerical results of the query are distributed among the queries is implementation-dependent. For example, some implementations may write each view’s results to a distinct query, while other implementations may write the total result to the first query and write zero to the other queries. However, the sum of the results in all the queries must accurately reflect the total result of the query summed over all views. Applications can sum the results from all the queries to compute the total result.

Queries used with multiview rendering must not span subpasses, i.e. they must begin and end in the same subpass.

To begin a query, call:

void vkCmdBeginQuery(
    VkCommandBuffer                             commandBuffer,
    VkQueryPool                                 queryPool,
    uint32_t                                    query,
    VkQueryControlFlags                         flags);

commandBuffer is the command buffer into which this command will be recorded.
queryPool is the query pool that will manage the results of the query.
query is the query index within the query pool that will contain the results.
flags is a bitmask of VkQueryControlFlagBits specifying constraints on the types of queries that can be performed.

If the queryType of the pool is VK_QUERY_TYPE_OCCLUSION and flags contains VK_QUERY_CONTROL_PRECISE_BIT, an implementation must return a result that matches the actual number of samples passed. This is described in more detail in Occlusion Queries.

Calling vkCmdBeginQuery is equivalent to calling vkCmdBeginQueryIndexedEXT with the index parameter set to zero.

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.

Valid Usage

VUID-vkCmdBeginQuery-queryPool-01922
queryPool must have been created with a queryType that differs from that of any queries that are active within commandBuffer
VUID-vkCmdBeginQuery-None-00807
All queries used by the command must be unavailable
VUID-vkCmdBeginQuery-queryType-02804
The queryType used to create queryPool must not be VK_QUERY_TYPE_TIMESTAMP
VUID-vkCmdBeginQuery-queryType-00800
If the precise occlusion queries feature is not enabled, or the queryType used to create queryPool was not VK_QUERY_TYPE_OCCLUSION, flags must not contain VK_QUERY_CONTROL_PRECISE_BIT
VUID-vkCmdBeginQuery-query-00802
query must be less than the number of queries in queryPool
VUID-vkCmdBeginQuery-queryType-00803
If the queryType used to create queryPool was VK_QUERY_TYPE_OCCLUSION, the VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdBeginQuery-queryType-00804
If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate graphics operations, the VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdBeginQuery-queryType-00805
If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate compute operations, the VkCommandPool that commandBuffer was allocated from must support compute operations
VUID-vkCmdBeginQuery-commandBuffer-01885
commandBuffer must not be a protected command buffer
VUID-vkCmdBeginQuery-query-00808
If called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool
VUID-vkCmdBeginQuery-queryType-02327
If the queryType used to create queryPool was VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT the VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdBeginQuery-queryType-02328
If the queryType used to create queryPool was VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT then VkPhysicalDeviceTransformFeedbackPropertiesEXT::transformFeedbackQueries must be supported
VUID-vkCmdBeginQuery-queryPool-03223
If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the profiling lock must have been held before vkBeginCommandBuffer was called on commandBuffer
VUID-vkCmdBeginQuery-queryPool-03224
If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one of the counters used to create queryPool was VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, the query begin must be the first recorded command in commandBuffer
VUID-vkCmdBeginQuery-queryPool-03225
If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one of the counters used to create queryPool was VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, the begin command must not be recorded within a render pass instance
VUID-vkCmdBeginQuery-queryPool-03226
If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and another query pool with a queryType VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR has been used within commandBuffer, its parent primary command buffer or secondary command buffer recorded within the same parent primary command buffer as commandBuffer, the performanceCounterMultipleQueryPools feature must be enabled
VUID-vkCmdBeginQuery-None-02863
This command must not be recorded in a command buffer that, either directly or through secondary command buffers, also contains a vkCmdResetQueryPool command affecting the same query.

Valid Usage (Implicit)

VUID-vkCmdBeginQuery-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdBeginQuery-queryPool-parameter
queryPool must be a valid VkQueryPool handle
VUID-vkCmdBeginQuery-flags-parameter
flags must be a valid combination of VkQueryControlFlagBits values
VUID-vkCmdBeginQuery-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdBeginQuery-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
VUID-vkCmdBeginQuery-commonparent
Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

To begin an indexed query, call:

void vkCmdBeginQueryIndexedEXT(
    VkCommandBuffer                             commandBuffer,
    VkQueryPool                                 queryPool,
    uint32_t                                    query,
    VkQueryControlFlags                         flags,
    uint32_t                                    index);

commandBuffer is the command buffer into which this command will be recorded.
queryPool is the query pool that will manage the results of the query.
query is the query index within the query pool that will contain the results.
flags is a bitmask of VkQueryControlFlagBits specifying constraints on the types of queries that can be performed.
index is the query type specific index. When the query type is VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT the index represents the vertex stream.

The vkCmdBeginQueryIndexedEXT command operates the same as the vkCmdBeginQuery command, except that it also accepts a query type specific index parameter.

Valid Usage

VUID-vkCmdBeginQueryIndexedEXT-queryPool-01922
queryPool must have been created with a queryType that differs from that of any queries that are active within commandBuffer
VUID-vkCmdBeginQueryIndexedEXT-None-00807
All queries used by the command must be unavailable
VUID-vkCmdBeginQueryIndexedEXT-queryType-02804
The queryType used to create queryPool must not be VK_QUERY_TYPE_TIMESTAMP
VUID-vkCmdBeginQueryIndexedEXT-queryType-00800
If the precise occlusion queries feature is not enabled, or the queryType used to create queryPool was not VK_QUERY_TYPE_OCCLUSION, flags must not contain VK_QUERY_CONTROL_PRECISE_BIT
VUID-vkCmdBeginQueryIndexedEXT-query-00802
query must be less than the number of queries in queryPool
VUID-vkCmdBeginQueryIndexedEXT-queryType-00803
If the queryType used to create queryPool was VK_QUERY_TYPE_OCCLUSION, the VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdBeginQueryIndexedEXT-queryType-00804
If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate graphics operations, the VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdBeginQueryIndexedEXT-queryType-00805
If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate compute operations, the VkCommandPool that commandBuffer was allocated from must support compute operations
VUID-vkCmdBeginQueryIndexedEXT-commandBuffer-01885
commandBuffer must not be a protected command buffer
VUID-vkCmdBeginQueryIndexedEXT-query-00808
If called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool
VUID-vkCmdBeginQueryIndexedEXT-queryType-02338
If the queryType used to create queryPool was VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT the VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdBeginQueryIndexedEXT-queryType-02339
If the queryType used to create queryPool was VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT the index parameter must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams
VUID-vkCmdBeginQueryIndexedEXT-queryType-02340
If the queryType used to create queryPool was not VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT the index must be zero
VUID-vkCmdBeginQueryIndexedEXT-queryType-02341
If the queryType used to create queryPool was VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT then VkPhysicalDeviceTransformFeedbackPropertiesEXT::transformFeedbackQueries must be supported
VUID-vkCmdBeginQueryIndexedEXT-queryPool-03223
If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the profiling lock must have been held before vkBeginCommandBuffer was called on commandBuffer
VUID-vkCmdBeginQueryIndexedEXT-queryPool-03224
If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one of the counters used to create queryPool was VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, the query begin must be the first recorded command in commandBuffer
VUID-vkCmdBeginQueryIndexedEXT-queryPool-03225
If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one of the counters used to create queryPool was VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, the begin command must not be recorded within a render pass instance
VUID-vkCmdBeginQueryIndexedEXT-queryPool-03226
If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and another query pool with a queryType VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR has been used within commandBuffer, its parent primary command buffer or secondary command buffer recorded within the same parent primary command buffer as commandBuffer, the performanceCounterMultipleQueryPools feature must be enabled
VUID-vkCmdBeginQueryIndexedEXT-None-02863
This command must not be recorded in a command buffer that, either directly or through secondary command buffers, also contains a vkCmdResetQueryPool command affecting the same query.

Valid Usage (Implicit)

VUID-vkCmdBeginQueryIndexedEXT-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdBeginQueryIndexedEXT-queryPool-parameter
queryPool must be a valid VkQueryPool handle
VUID-vkCmdBeginQueryIndexedEXT-flags-parameter
flags must be a valid combination of VkQueryControlFlagBits values
VUID-vkCmdBeginQueryIndexedEXT-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdBeginQueryIndexedEXT-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
VUID-vkCmdBeginQueryIndexedEXT-commonparent
Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

Bits which can be set in vkCmdBeginQuery::flags, specifying constraints on the types of queries that can be performed, are:

typedef enum VkQueryControlFlagBits {
    VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
    VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkQueryControlFlagBits;

VK_QUERY_CONTROL_PRECISE_BIT specifies the precision of occlusion queries.

typedef VkFlags VkQueryControlFlags;

VkQueryControlFlags is a bitmask type for setting a mask of zero or more VkQueryControlFlagBits.

To end a query after the set of desired draw or dispatch commands is executed, call:

void vkCmdEndQuery(
    VkCommandBuffer                             commandBuffer,
    VkQueryPool                                 queryPool,
    uint32_t                                    query);

commandBuffer is the command buffer into which this command will be recorded.
queryPool is the query pool that is managing the results of the query.
query is the query index within the query pool where the result is stored.

Calling vkCmdEndQuery is equivalent to calling vkCmdEndQueryIndexedEXT with the index parameter set to zero.

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 vkGetQueryPoolResults and vkCmdCopyQueryPoolResults, 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.

Valid Usage

VUID-vkCmdEndQuery-None-01923
All queries used by the command must be active
VUID-vkCmdEndQuery-query-00810
query must be less than the number of queries in queryPool
VUID-vkCmdEndQuery-commandBuffer-01886
commandBuffer must not be a protected command buffer
VUID-vkCmdEndQuery-query-00812
If vkCmdEndQuery is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool
VUID-vkCmdEndQuery-queryPool-03227
If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one or more of the counters used to create queryPool was VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, the vkCmdEndQuery must be the last recorded command in commandBuffer
VUID-vkCmdEndQuery-queryPool-03228
If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one or more of the counters used to create queryPool was VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, the vkCmdEndQuery must not be recorded within a render pass instance

Valid Usage (Implicit)

VUID-vkCmdEndQuery-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdEndQuery-queryPool-parameter
queryPool must be a valid VkQueryPool handle
VUID-vkCmdEndQuery-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdEndQuery-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
VUID-vkCmdEndQuery-commonparent
Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

To end an indexed query after the set of desired draw or dispatch commands is recorded, call:

void vkCmdEndQueryIndexedEXT(
    VkCommandBuffer                             commandBuffer,
    VkQueryPool                                 queryPool,
    uint32_t                                    query,
    uint32_t                                    index);

commandBuffer is the command buffer into which this command will be recorded.
queryPool is the query pool that is managing the results of the query.
query is the query index within the query pool where the result is stored.
index is the query type specific index.

The vkCmdEndQueryIndexedEXT command operates the same as the vkCmdEndQuery command, except that it also accepts a query type specific index parameter.

Valid Usage

VUID-vkCmdEndQueryIndexedEXT-None-02342
All queries used by the command must be active
VUID-vkCmdEndQueryIndexedEXT-query-02343
query must be less than the number of queries in queryPool
VUID-vkCmdEndQueryIndexedEXT-commandBuffer-02344
commandBuffer must not be a protected command buffer
VUID-vkCmdEndQueryIndexedEXT-query-02345
If vkCmdEndQueryIndexedEXT is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool
VUID-vkCmdEndQueryIndexedEXT-queryType-02346
If the queryType used to create queryPool was VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT the index parameter must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams
VUID-vkCmdEndQueryIndexedEXT-queryType-02347
If the queryType used to create queryPool was not VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT the index must be zero
VUID-vkCmdEndQueryIndexedEXT-queryType-02723
If the queryType used to create queryPool was VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT index must equal the index used to begin the query

Valid Usage (Implicit)

VUID-vkCmdEndQueryIndexedEXT-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdEndQueryIndexedEXT-queryPool-parameter
queryPool must be a valid VkQueryPool handle
VUID-vkCmdEndQueryIndexedEXT-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdEndQueryIndexedEXT-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
VUID-vkCmdEndQueryIndexedEXT-commonparent
Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

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.
Occlusion queries, pipeline statistics queries, transform feedback queries, and timestamp queries store results in 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.
Performance queries store results in a tightly packed array whose type is determined by the unit member of the corresponding VkPerformanceCounterKHR.
If VK_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. Timestamp queries write one integer value. Performance queries write one VkPerformanceCounterResultKHR value for each VkPerformanceCounterKHR in the query. Transform feedback queries write two integers; the first integer is the number of primitives successfully written to the corresponding transform feedback buffer and the second is the number of primitives output to the vertex stream, regardless of whether they were successfully captured or not. In other words, if the transform feedback buffer was sized too small for the number of primitives output by the vertex stream, the first integer represents the number of primitives actually written and the second is the number that would have been written if all the transform feedback buffers associated with that vertex stream were large enough.
If more than one query is retrieved and stride is not at least as large as the size of the array of values corresponding to a single query, the values written to memory are undefined.

To retrieve status and results for a set of queries, call:

VkResult vkGetQueryPoolResults(
    VkDevice                                    device,
    VkQueryPool                                 queryPool,
    uint32_t                                    firstQuery,
    uint32_t                                    queryCount,
    size_t                                      dataSize,
    void*                                       pData,
    VkDeviceSize                                stride,
    VkQueryResultFlags                          flags);

device is the logical device that owns the query pool.
queryPool is the query pool managing the queries containing the desired results.
firstQuery is the initial query index.
queryCount is the number of queries to read.
dataSize is the size in bytes of the buffer pointed to by pData.
pData is a pointer to a user-allocated buffer where the results will be written
stride is the stride in bytes between results for individual queries within pData.
flags is a bitmask of VkQueryResultFlagBits specifying how and when results are returned.

The range of queries read is defined by [firstQuery, firstQuery + queryCount - 1]. For pipeline statistics queries, each query index in the pool contains one integer value for each bit that is enabled in VkQueryPoolCreateInfo::pipelineStatistics when the pool is created.

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 VK_QUERY_RESULT_64_BIT is not set and the result overflows a 32-bit value, the value may either wrap or saturate. Similarly, if VK_QUERY_RESULT_64_BIT is set and the result overflows a 64-bit value, the value may either wrap or saturate.

If VK_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 VK_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 VK_QUERY_RESULT_WAIT_BIT and VK_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 VK_NOT_READY. However, availability state is still written to pData for those queries if VK_QUERY_RESULT_WITH_AVAILABILITY_BIT is set.

Note

Applications must take care to ensure that use of the VK_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 vkCmdResetQueryPool, vkCmdBeginQuery, and vkCmdEndQuery for that query, then the query will remain in the available state until vkResetQueryPool is called or the vkCmdResetQueryPool command executes on a queue. Applications can use fences or events to ensure that a 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 VK_QUERY_RESULT_WAIT_BIT is used in combination with VK_QUERY_RESULT_WITH_AVAILABILITY_BIT. In this case, the returned availability status may reflect the result of a previous use of the query unless vkResetQueryPool is called or 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 VK_QUERY_RESULT_PARTIAL_BIT is set, VK_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.

If VK_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 VK_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

VUID-vkGetQueryPoolResults-firstQuery-00813
firstQuery must be less than the number of queries in queryPool
VUID-vkGetQueryPoolResults-flags-02827
If VK_QUERY_RESULT_64_BIT is not set in flags, then pData and stride must be multiples of 4
VUID-vkGetQueryPoolResults-flags-02828
If VK_QUERY_RESULT_64_BIT is not set in flags and the queryType used to create queryPool was not VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, then pData and stride must be multiples of 4
VUID-vkGetQueryPoolResults-flags-00815
If VK_QUERY_RESULT_64_BIT is set in flags then pData and stride must be multiples of 8
VUID-vkGetQueryPoolResults-queryType-03229
If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, then pData and stride must be multiples of the size of VkPerformanceCounterResultKHR
VUID-vkGetQueryPoolResults-firstQuery-00816
The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool
VUID-vkGetQueryPoolResults-dataSize-00817
dataSize must be large enough to contain the result of each query, as described here
VUID-vkGetQueryPoolResults-queryType-00818
If the queryType used to create queryPool was VK_QUERY_TYPE_TIMESTAMP, flags must not contain VK_QUERY_RESULT_PARTIAL_BIT
VUID-vkGetQueryPoolResults-queryType-03230
If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, flags must not contain VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, VK_QUERY_RESULT_PARTIAL_BIT or VK_QUERY_RESULT_64_BIT
VUID-vkGetQueryPoolResults-queryType-03231
If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the queryPool must have been recorded once for each pass as retrieved via a call to vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR

Valid Usage (Implicit)

VUID-vkGetQueryPoolResults-device-parameter
device must be a valid VkDevice handle
VUID-vkGetQueryPoolResults-queryPool-parameter
queryPool must be a valid VkQueryPool handle
VUID-vkGetQueryPoolResults-pData-parameter
pData must be a valid pointer to an array of dataSize bytes
VUID-vkGetQueryPoolResults-flags-parameter
flags must be a valid combination of VkQueryResultFlagBits values
VUID-vkGetQueryPoolResults-dataSize-arraylength
dataSize must be greater than 0
VUID-vkGetQueryPoolResults-queryPool-parent
queryPool must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS
VK_NOT_READY

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST

Bits which can be set in vkGetQueryPoolResults::flags and vkCmdCopyQueryPoolResults::flags, specifying how and when results are returned, are:

typedef enum VkQueryResultFlagBits {
    VK_QUERY_RESULT_64_BIT = 0x00000001,
    VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
    VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
    VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
    VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkQueryResultFlagBits;

VK_QUERY_RESULT_64_BIT specifies 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.
VK_QUERY_RESULT_WAIT_BIT specifies that Vulkan will wait for each query’s status to become available before retrieving its results.
VK_QUERY_RESULT_WITH_AVAILABILITY_BIT specifies that the availability status accompanies the results.
VK_QUERY_RESULT_PARTIAL_BIT specifies that returning partial results is acceptable.

typedef VkFlags VkQueryResultFlags;

VkQueryResultFlags is a bitmask type for setting a mask of zero or more VkQueryResultFlagBits.

To copy query statuses and numerical results directly to buffer memory, call:

void vkCmdCopyQueryPoolResults(
    VkCommandBuffer                             commandBuffer,
    VkQueryPool                                 queryPool,
    uint32_t                                    firstQuery,
    uint32_t                                    queryCount,
    VkBuffer                                    dstBuffer,
    VkDeviceSize                                dstOffset,
    VkDeviceSize                                stride,
    VkQueryResultFlags                          flags);

commandBuffer is the command buffer into which this command will be recorded.
queryPool is the query pool managing the queries containing the desired results.
firstQuery is the initial query index.
queryCount is the number of queries. firstQuery and queryCount together define a range of queries.
dstBuffer is a VkBuffer object that will receive the results of the copy command.
dstOffset is an offset into dstBuffer.
stride is the stride in bytes between results for individual queries within dstBuffer. The required size of the backing memory for dstBuffer is determined as described above for vkGetQueryPoolResults.
flags is a bitmask of VkQueryResultFlagBits specifying how and when results are returned.

vkCmdCopyQueryPoolResults is guaranteed to see the effect of previous uses of vkCmdResetQueryPool 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 vkGetQueryPoolResults, 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.

Results for all requested occlusion queries, pipeline statistics queries, transform feedback queries, and timestamp queries are written as 64-bit unsigned integer values if VK_QUERY_RESULT_64_BIT is set or 32-bit unsigned integer values otherwise. Performance queries store results in a tightly packed array whose type is determined by the unit member of the corresponding VkPerformanceCounterKHR.

If neither of VK_QUERY_RESULT_WAIT_BIT and VK_QUERY_RESULT_WITH_AVAILABILITY_BIT are set, results are only written out for queries in the available state.

If VK_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 VK_ERROR_DEVICE_LOST error may occur.

Similarly, if VK_QUERY_RESULT_WITH_AVAILABILITY_BIT is set and VK_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.

VK_QUERY_RESULT_PARTIAL_BIT must not be used if the pool’s queryType is VK_QUERY_TYPE_TIMESTAMP.

vkCmdCopyQueryPoolResults is considered to be a transfer operation, and its writes to buffer memory must be synchronized using VK_PIPELINE_STAGE_TRANSFER_BIT and VK_ACCESS_TRANSFER_WRITE_BIT before using the results.

Valid Usage

VUID-vkCmdCopyQueryPoolResults-dstOffset-00819
dstOffset must be less than the size of dstBuffer
VUID-vkCmdCopyQueryPoolResults-firstQuery-00820
firstQuery must be less than the number of queries in queryPool
VUID-vkCmdCopyQueryPoolResults-firstQuery-00821
The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool
VUID-vkCmdCopyQueryPoolResults-flags-00822
If VK_QUERY_RESULT_64_BIT is not set in flags then dstOffset and stride must be multiples of 4
VUID-vkCmdCopyQueryPoolResults-flags-00823
If VK_QUERY_RESULT_64_BIT is set in flags then dstOffset and stride must be multiples of 8
VUID-vkCmdCopyQueryPoolResults-dstBuffer-00824
dstBuffer must have enough storage, from dstOffset, to contain the result of each query, as described here
VUID-vkCmdCopyQueryPoolResults-dstBuffer-00825
dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag
VUID-vkCmdCopyQueryPoolResults-dstBuffer-00826
If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdCopyQueryPoolResults-queryType-00827
If the queryType used to create queryPool was VK_QUERY_TYPE_TIMESTAMP, flags must not contain VK_QUERY_RESULT_PARTIAL_BIT
VUID-vkCmdCopyQueryPoolResults-queryType-03232
If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, VkPhysicalDevicePerformanceQueryPropertiesKHR::allowCommandBufferQueryCopies must be VK_TRUE
VUID-vkCmdCopyQueryPoolResults-queryType-03233
If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, flags must not contain VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, VK_QUERY_RESULT_PARTIAL_BIT or VK_QUERY_RESULT_64_BIT
VUID-vkCmdCopyQueryPoolResults-queryType-03234
If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the queryPool must have been submitted once for each pass as retrieved via a call to vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR
VUID-vkCmdCopyQueryPoolResults-queryType-02734
vkCmdCopyQueryPoolResults must not be called if the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL

Valid Usage (Implicit)

VUID-vkCmdCopyQueryPoolResults-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdCopyQueryPoolResults-queryPool-parameter
queryPool must be a valid VkQueryPool handle
VUID-vkCmdCopyQueryPoolResults-dstBuffer-parameter
dstBuffer must be a valid VkBuffer handle
VUID-vkCmdCopyQueryPoolResults-flags-parameter
flags must be a valid combination of VkQueryResultFlagBits values
VUID-vkCmdCopyQueryPoolResults-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdCopyQueryPoolResults-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
VUID-vkCmdCopyQueryPoolResults-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdCopyQueryPoolResults-commonparent
Each of commandBuffer, dstBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Graphics
Compute

Transfer

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.

17.3. Occlusion Queries

Occlusion queries track the number of samples that pass the per-fragment tests for a set of drawing commands. As such, occlusion queries are only available on queue families supporting graphics operations. The application can then use these results to inform future rendering decisions. An occlusion query is begun and ended by calling vkCmdBeginQuery and vkCmdEndQuery, respectively. When an occlusion query begins, the count of passing samples always starts at zero. For each drawing command, the count is incremented as described in Sample Counting. If flags does not contain VK_QUERY_CONTROL_PRECISE_BIT an implementation may generate any non-zero result value for the query if the count of passing samples is non-zero.

Note

Not setting VK_QUERY_CONTROL_PRECISE_BIT mode may be more efficient on some implementations, and should be used where it is sufficient to know a boolean result on whether any samples passed the per-fragment tests. In this case, some implementations may only return zero or one, indifferent to the actual number of samples passing the per-fragment tests.

When an occlusion query finishes, the result for that query is marked as available. The application can then either copy the result to a buffer (via vkCmdCopyQueryPoolResults) or request it be put into host memory (via vkGetQueryPoolResults).

Note

If occluding geometry is not drawn first, samples can pass the depth test, but still not be visible in a final image.

17.4. Pipeline Statistics Queries

Pipeline statistics queries allow the application to sample a specified set of VkPipeline counters. These counters are accumulated by Vulkan for a set of either draw or dispatch commands while a pipeline statistics query is active. As such, pipeline statistics queries are available on queue families supporting either graphics or compute operations. The availability of pipeline statistics queries is indicated by the pipelineStatisticsQuery member of the VkPhysicalDeviceFeatures object (see vkGetPhysicalDeviceFeatures and vkCreateDevice for detecting and requesting this query type on a VkDevice).

A pipeline statistics query is begun and ended by calling vkCmdBeginQuery and vkCmdEndQuery, respectively. When a pipeline statistics query begins, all statistics counters are set to zero. While the query is active, the pipeline type determines which set of statistics are available, but these must be configured on the query pool when it is created. If a statistic counter is issued on a command buffer that does not support the corresponding operation, the value of that counter is undefined after the query has finished. At least one statistic counter relevant to the operations supported on the recording command buffer must be enabled.

Bits which can be set to individually enable pipeline statistics counters for query pools with VkQueryPoolCreateInfo::pipelineStatistics, and for secondary command buffers with VkCommandBufferInheritanceInfo::pipelineStatistics, are:

typedef enum VkQueryPipelineStatisticFlagBits {
    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
    VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,
    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,
    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,
    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,
    VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,
    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,
    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,
    VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400,
    VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkQueryPipelineStatisticFlagBits;

VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT specifies that 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.
VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT specifies that 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.
VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT specifies that 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.
VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT specifies that 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.
VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT specifies that 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.
VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT specifies that 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.
VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT specifies that 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.
VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT specifies that 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.
VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT specifies that 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.
VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT specifies that 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.
VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT specifies that 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.

These values are intended to measure relative statistics on one implementation. Various device architectures will count these values differently. Any or all counters may be affected by the issues described in Query Operation.

Note

For example, tile-based rendering devices may need to replay the scene multiple times, affecting some of the counts.

If a pipeline has rasterizerDiscardEnable enabled, implementations may discard primitives after the final vertex processing stage. As a result, if rasterizerDiscardEnable is enabled, the clipping input and output primitives counters may not be incremented.

When a pipeline statistics query finishes, the result for that query is marked as available. The application can copy the result to a buffer (via vkCmdCopyQueryPoolResults), or request it be put into host memory (via vkGetQueryPoolResults).

typedef VkFlags VkQueryPipelineStatisticFlags;

VkQueryPipelineStatisticFlags is a bitmask type for setting a mask of zero or more VkQueryPipelineStatisticFlagBits.

17.5. Timestamp Queries

Timestamps provide applications with a mechanism for timing the execution of commands. A timestamp is an integer value generated by the VkPhysicalDevice. Unlike other queries, timestamps do not operate over a range, and so do not use vkCmdBeginQuery or vkCmdEndQuery. The mechanism is built around a set of commands that allow the application to tell the VkPhysicalDevice to write timestamp values to a query pool and then either read timestamp values on the host (using vkGetQueryPoolResults) or copy timestamp values to a VkBuffer (using vkCmdCopyQueryPoolResults). The application can then compute differences between timestamps to determine execution time.

The number of valid bits in a timestamp value is determined by the VkQueueFamilyProperties::timestampValidBits property of the queue on which the timestamp is written. Timestamps are supported on any queue which reports a non-zero value for timestampValidBits via vkGetPhysicalDeviceQueueFamilyProperties. If the timestampComputeAndGraphics limit is VK_TRUE, timestamps are supported by every queue family that supports either graphics or compute operations (see VkQueueFamilyProperties).

The number of nanoseconds it takes for a timestamp value to be incremented by 1 can be obtained from VkPhysicalDeviceLimits::timestampPeriod after a call to vkGetPhysicalDeviceProperties.

To request a timestamp, call:

void vkCmdWriteTimestamp(
    VkCommandBuffer                             commandBuffer,
    VkPipelineStageFlagBits                     pipelineStage,
    VkQueryPool                                 queryPool,
    uint32_t                                    query);

commandBuffer is the command buffer into which the command will be recorded.
pipelineStage is one of the VkPipelineStageFlagBits, specifying a stage of the pipeline.
queryPool is the query pool that will manage the timestamp.
query is the query within the query pool that will contain the timestamp.

vkCmdWriteTimestamp latches the value of the timer when all previous commands have completed executing as far as the specified pipeline stage, and writes the timestamp value to memory. When the timestamp value is written, the availability status of the query is set to available.

Note

If an implementation is unable to detect completion and latch the timer at any specific stage of the pipeline, it may instead do so at any logically later stage.

vkCmdCopyQueryPoolResults can then be called to copy the timestamp value from the query pool into buffer memory, with ordering and synchronization behavior equivalent to how other queries operate. Timestamp values can also be retrieved from the query pool using vkGetQueryPoolResults. As with other queries, the query must be reset using vkCmdResetQueryPool or vkResetQueryPool before requesting the timestamp value be written to it.

While vkCmdWriteTimestamp can be called inside or outside of a render pass instance, vkCmdCopyQueryPoolResults must only be called outside of a render pass instance.

Timestamps may only be meaningfully compared if they are written by commands submitted to the same queue.

Note

An example of such a comparison is determining the execution time of a sequence of commands.

If vkCmdWriteTimestamp is called while executing a render pass instance that has multiview enabled, the timestamp uses N consecutive query indices in the query pool (starting at query) where N is the number of bits set in the view mask of the subpass the command is executed in. The resulting query values are determined by an implementation-dependent choice of one of the following behaviors:

The first query is a timestamp value and (if more than one bit is set in the view mask) zero is written to the remaining queries. If two timestamps are written in the same subpass, the sum of the execution time of all views between those commands is the difference between the first query written by each command.
All N queries are timestamp values. If two timestamps are written in the same subpass, the sum of the execution time of all views between those commands is the sum of the difference between corresponding queries written by each command. The difference between corresponding queries may be the execution time of a single view.

In either case, the application can sum the differences between all N queries to determine the total execution time.

Valid Usage

VUID-vkCmdWriteTimestamp-queryPool-01416
queryPool must have been created with a queryType of VK_QUERY_TYPE_TIMESTAMP
VUID-vkCmdWriteTimestamp-queryPool-00828
The query identified by queryPool and query must be unavailable
VUID-vkCmdWriteTimestamp-timestampValidBits-00829
The command pool’s queue family must support a non-zero timestampValidBits
VUID-vkCmdWriteTimestamp-None-00830
All queries used by the command must be unavailable
VUID-vkCmdWriteTimestamp-query-00831
If vkCmdWriteTimestamp is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool

Valid Usage (Implicit)

VUID-vkCmdWriteTimestamp-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdWriteTimestamp-pipelineStage-parameter
pipelineStage must be a valid VkPipelineStageFlagBits value
VUID-vkCmdWriteTimestamp-queryPool-parameter
queryPool must be a valid VkQueryPool handle
VUID-vkCmdWriteTimestamp-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdWriteTimestamp-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations
VUID-vkCmdWriteTimestamp-commonparent
Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Transfer
Graphics
Compute

Transfer

17.6. Performance Queries

Performance queries provide applications with a mechanism for getting performance counter information about the execution of command buffers, render passes, and commands.

Each queue family advertises the performance counters that can be queried on a queue of that family via a call to vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR. Implementations may limit access to performance counters based on platform requirements or only to specialized drivers for development purposes.

Note

This may include no performance counters being enumerated, or a reduced set. Please refer to platform-specific documentation for guidance on any such restrictions.

Performance queries use the existing vkCmdBeginQuery and vkCmdEndQuery to control what command buffers, render passes, or commands to get performance information for.

Implementations may require multiple passes where the command buffer, render passes, or commands being recorded are the same and are executed on the same queue to record performance counter data. This is achieved by submitting the same batch and providing a VkPerformanceQuerySubmitInfoKHR structure containing a counter pass index. The number of passes required for a given performance query pool can be queried via a call to vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.

Note

Command buffers created with VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT must not be re-submitted. Changing command buffer usage bits may affect performance. To avoid this, the application should re-record any command buffers with the VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT when multiple counter passes are required.

Performance counter results from a performance query pool can be obtained with the command vkGetQueryPoolResults.

Performance query results are returned in an array of VkPerformanceCounterResultKHR unions containing the data associated with each counter in the query, stored in the same order as the counters supplied in pCounterIndices when creating the performance query. The VkPerformanceCounterKHR::unit enumeration specifies how to parse the counter data.

typedef union VkPerformanceCounterResultKHR {
    int32_t     int32;
    int64_t     int64;
    uint32_t    uint32;
    uint64_t    uint64;
    float       float32;
    double      float64;
} VkPerformanceCounterResultKHR;

17.6.1. Profiling Lock

To record and submit a command buffer that contains a performance query pool the profiling lock must be held. The profiling lock must be acquired prior to any call to vkBeginCommandBuffer that will be using a performance query pool. The profiling lock must be held while any command buffer that contains a performance query pool is in the recording, executable, or pending state. To acquire the profiling lock, call:

VkResult vkAcquireProfilingLockKHR(
    VkDevice                                    device,
    const VkAcquireProfilingLockInfoKHR*        pInfo);

device is the logical device to profile.
pInfo is a pointer to a VkAcquireProfilingLockInfoKHR structure which contains information about how the profiling is to be acquired.

Implementations may allow multiple actors to hold the profiling lock concurrently.

Valid Usage (Implicit)

VUID-vkAcquireProfilingLockKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkAcquireProfilingLockKHR-pInfo-parameter
pInfo must be a valid pointer to a valid VkAcquireProfilingLockInfoKHR structure

Return Codes

VK_SUCCESS

VK_TIMEOUT

The VkAcquireProfilingLockInfoKHR structure is defined as:

typedef struct VkAcquireProfilingLockInfoKHR {
    VkStructureType                   sType;
    const void*                       pNext;
    VkAcquireProfilingLockFlagsKHR    flags;
    uint64_t                          timeout;
} VkAcquireProfilingLockInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
timeout indicates how long the function waits, in nanoseconds, if the profiling lock is not available.

Valid Usage (Implicit)

VUID-VkAcquireProfilingLockInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR
VUID-VkAcquireProfilingLockInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkAcquireProfilingLockInfoKHR-flags-zerobitmask
flags must be 0

If timeout is 0, vkAcquireProfilingLockKHR will not block while attempting to acquire the profling lock. If timeout is UINT64_MAX, the function will not return until the profiling lock was acquired.

typedef enum VkAcquireProfilingLockFlagBitsKHR {
    VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkAcquireProfilingLockFlagBitsKHR;

typedef VkFlags VkAcquireProfilingLockFlagsKHR;

VkAcquireProfilingLockFlagsKHR is a bitmask type for setting a mask, but is currently reserved for future use.

To release the profiling lock, call:

void vkReleaseProfilingLockKHR(
    VkDevice                                    device);

device is the logical device to cease profiling on.

Valid Usage

VUID-vkReleaseProfilingLockKHR-device-03235
The profiling lock of device must have been held via a previous successful call to vkAcquireProfilingLockKHR

Valid Usage (Implicit)

VUID-vkReleaseProfilingLockKHR-device-parameter
device must be a valid VkDevice handle

17.7. Transform Feedback Queries

Transform feedback queries track the number of primitives attempted to be written and actually written, by the vertex stream being captured, to a transform feedback buffer. This query is updated during draw commands while transform feedback is active. The number of primitives actually written will be less than the number attempted to be written if the bound transform feedback buffer size was too small for the number of primitives actually drawn. Primitives are not written beyond the bound range of the transform feedback buffer. A transform feedback query is begun and ended by calling vkCmdBeginQuery and vkCmdEndQuery, respectively to query for vertex stream zero. vkCmdBeginQueryIndexedEXT and vkCmdEndQueryIndexedEXT can be used to begin and end transform feedback queries for any supported vertex stream. When a transform feedback query begins, the count of primitives written and primitives needed starts from zero. For each drawing command, the count is incremented as vertex attribute outputs are captured to the transform feedback buffers while transform feedback is active.

When a transform feedback query finishes, the result for that query is marked as available. The application can then either copy the result to a buffer (via vkCmdCopyQueryPoolResults) or request it be put into host memory (via vkGetQueryPoolResults).

17.8. Intel performance queries

Intel performance queries allow an application to capture performance data for a set of commands. Performance queries are used in a similar way than other types of queries. A main difference with existing queries is that the resulting data should be handed over to a library capabable to produce human readable results rather than being read directly by an application.

Prior to creating a performance query pool, initialize the device for performance queries with the call:

VkResult vkInitializePerformanceApiINTEL(
    VkDevice                                    device,
    const VkInitializePerformanceApiInfoINTEL*  pInitializeInfo);

device is the logical device used for the queries.
pInitializeInfo is a pointer to a VkInitializePerformanceApiInfoINTEL structure specifying initialization parameters.

Valid Usage (Implicit)

VUID-vkInitializePerformanceApiINTEL-device-parameter
device must be a valid VkDevice handle
VUID-vkInitializePerformanceApiINTEL-pInitializeInfo-parameter
pInitializeInfo must be a valid pointer to a valid VkInitializePerformanceApiInfoINTEL structure

Return Codes

VK_SUCCESS

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

The VkInitializePerformanceApiInfoINTEL structure is defined as :

typedef struct VkInitializePerformanceApiInfoINTEL {
    VkStructureType    sType;
    const void*        pNext;
    void*              pUserData;
} VkInitializePerformanceApiInfoINTEL;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
pUserData is a pointer for application data.

Valid Usage (Implicit)

VUID-VkInitializePerformanceApiInfoINTEL-sType-sType
sType must be VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL
VUID-VkInitializePerformanceApiInfoINTEL-pNext-pNext
pNext must be NULL

Once performance query operations have completed, uninitalize the device for performance queries with the call:

void vkUninitializePerformanceApiINTEL(
    VkDevice                                    device);

device is the logical device used for the queries.

Valid Usage (Implicit)

VUID-vkUninitializePerformanceApiINTEL-device-parameter
device must be a valid VkDevice handle

Some performance query features of a device can be discovered with the call:

VkResult vkGetPerformanceParameterINTEL(
    VkDevice                                    device,
    VkPerformanceParameterTypeINTEL             parameter,
    VkPerformanceValueINTEL*                    pValue);

device is the logical device to query.
parameter is the parameter to query.
pValue is a pointer to a VkPerformanceValueINTEL structure in which the type and value of the parameter are returned.

Valid Usage (Implicit)

VUID-vkGetPerformanceParameterINTEL-device-parameter
device must be a valid VkDevice handle
VUID-vkGetPerformanceParameterINTEL-parameter-parameter
parameter must be a valid VkPerformanceParameterTypeINTEL value
VUID-vkGetPerformanceParameterINTEL-pValue-parameter
pValue must be a valid pointer to a VkPerformanceValueINTEL structure

Return Codes

VK_SUCCESS

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

Possible values of vkGetPerformanceParameterINTEL::parameter, specifying a performance query feature, are:

typedef enum VkPerformanceParameterTypeINTEL {
    VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0,
    VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1,
    VK_PERFORMANCE_PARAMETER_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
} VkPerformanceParameterTypeINTEL;

VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL has a boolean result which tells whether hardware counters can be captured.
VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL has a 32 bits integer result which tells how many bits can be written into the VkPerformanceValueINTEL value.

The VkPerformanceValueINTEL structure is defined as:

typedef struct VkPerformanceValueINTEL {
    VkPerformanceValueTypeINTEL    type;
    VkPerformanceValueDataINTEL    data;
} VkPerformanceValueINTEL;

type is a VkPerformanceValueTypeINTEL value specifying the type of the returned data.
data is a VkPerformanceValueDataINTEL union specifying the value of the returned data.

Valid Usage (Implicit)

VUID-VkPerformanceValueINTEL-type-parameter
type must be a valid VkPerformanceValueTypeINTEL value
VUID-VkPerformanceValueINTEL-data-parameter
data must be a valid VkPerformanceValueDataINTEL union

Possible values of VkPerformanceValueINTEL::type, specifying the type of the data returned in VkPerformanceValueINTEL::data, are:

VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL specifies that unsigned 32-bit integer data is returned in data.value32.
VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL specifies that unsigned 64-bit integer data is returned in data.value64.
VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL specifies that floating-point data is returned in data.valueFloat.
VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL specifies that Bool32 data is returned in data.valueBool.
VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL specifies that a pointer to a null-terminated UTF-8 string is returned in data.valueString. The pointer is valid for the lifetime of the device parameter passed to vkGetPerformanceParameterINTEL.

typedef enum VkPerformanceValueTypeINTEL {
    VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0,
    VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1,
    VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2,
    VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3,
    VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4,
    VK_PERFORMANCE_VALUE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
} VkPerformanceValueTypeINTEL;

The VkPerformanceValueDataINTEL union is defined as:

typedef union VkPerformanceValueDataINTEL {
    uint32_t       value32;
    uint64_t       value64;
    float          valueFloat;
    VkBool32       valueBool;
    const char*    valueString;
} VkPerformanceValueDataINTEL;

data.value32 represents 32-bit integer data.
data.value64 represents 64-bit integer data.
data.valueFloat represents floating-point data.
data.valueBool represents Bool32 data.
data.valueString represents a pointer to a null-terminated UTF-8 string.

The correct member of the union is determined by the associated VkPerformanceValueTypeINTEL value.

Valid Usage (Implicit)

VUID-VkPerformanceValueDataINTEL-valueString-parameter
valueString must be a valid pointer to a valid

The VkQueryPoolCreateInfoINTEL structure is defined as:

typedef struct VkQueryPoolCreateInfoINTEL {
    VkStructureType                 sType;
    const void*                     pNext;
    VkQueryPoolSamplingModeINTEL    performanceCountersSampling;
} VkQueryPoolCreateInfoINTEL;

To create a pool for Intel performance queries, set VkQueryPoolCreateInfo::queryType to VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL and add a VkQueryPoolCreateInfoINTEL structure to the pNext chain of the VkQueryPoolCreateInfo structure.

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
performanceCountersSampling describe how performance queries should be captured.

Valid Usage (Implicit)

VUID-VkQueryPoolCreateInfoINTEL-sType-sType
sType must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL
VUID-VkQueryPoolCreateInfoINTEL-pNext-pNext
pNext must be NULL
VUID-VkQueryPoolCreateInfoINTEL-performanceCountersSampling-parameter
performanceCountersSampling must be a valid VkQueryPoolSamplingModeINTEL value

Possible values of VkQueryPoolCreateInfoINTEL::performanceCountersSampling are:

typedef enum VkQueryPoolSamplingModeINTEL {
    VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0,
    VK_QUERY_POOL_SAMPLING_MODE_MAX_ENUM_INTEL = 0x7FFFFFFF
} VkQueryPoolSamplingModeINTEL;

VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL is the default mode in which the application calls vkCmdBeginQuery and vkCmdEndQuery to record performance data.

To help associate query results with a particular point at which an application emitted commands, markers can be set into the command buffers with the call:

VkResult vkCmdSetPerformanceMarkerINTEL(
    VkCommandBuffer                             commandBuffer,
    const VkPerformanceMarkerInfoINTEL*         pMarkerInfo);

The last marker set onto a command buffer before the end of a query will be part of the query result.

Valid Usage (Implicit)

VUID-vkCmdSetPerformanceMarkerINTEL-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetPerformanceMarkerINTEL-pMarkerInfo-parameter
pMarkerInfo must be a valid pointer to a valid VkPerformanceMarkerInfoINTEL structure
VUID-vkCmdSetPerformanceMarkerINTEL-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetPerformanceMarkerINTEL-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, compute, or transfer operations

Host Synchronization

Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute
Transfer

Return Codes

VK_SUCCESS

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

The VkPerformanceMarkerInfoINTEL structure is defined as:

typedef struct VkPerformanceMarkerInfoINTEL {
    VkStructureType    sType;
    const void*        pNext;
    uint64_t           marker;
} VkPerformanceMarkerInfoINTEL;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
marker is the marker value that will be recorded into the opaque query results.

Valid Usage (Implicit)

VUID-VkPerformanceMarkerInfoINTEL-sType-sType
sType must be VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL
VUID-VkPerformanceMarkerInfoINTEL-pNext-pNext
pNext must be NULL

When monitoring the behavior of an application wihtin the dataset generated by the entire set of applications running on the system, it is useful to identify draw calls within a potentially huge amount of performance data. To do so, application can generate stream markers that will be used to trace back a particular draw call with a particular performance data item.

VkResult vkCmdSetPerformanceStreamMarkerINTEL(
    VkCommandBuffer                             commandBuffer,
    const VkPerformanceStreamMarkerInfoINTEL*   pMarkerInfo);

Valid Usage (Implicit)

VUID-vkCmdSetPerformanceStreamMarkerINTEL-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetPerformanceStreamMarkerINTEL-pMarkerInfo-parameter
pMarkerInfo must be a valid pointer to a valid VkPerformanceStreamMarkerInfoINTEL structure
VUID-vkCmdSetPerformanceStreamMarkerINTEL-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetPerformanceStreamMarkerINTEL-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, compute, or transfer operations

Host Synchronization

Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute
Transfer

Return Codes

VK_SUCCESS

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

The VkPerformanceStreamMarkerInfoINTEL structure is defined as:

typedef struct VkPerformanceStreamMarkerInfoINTEL {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           marker;
} VkPerformanceStreamMarkerInfoINTEL;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
marker is the marker value that will be recorded into the reports consumed by an external application.

Valid Usage

VUID-VkPerformanceStreamMarkerInfoINTEL-marker-02735
The value written by the application into marker must only used the valid bits as reported by vkGetPerformanceParameterINTEL with the VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL.

Valid Usage (Implicit)

VUID-VkPerformanceStreamMarkerInfoINTEL-sType-sType
sType must be VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL
VUID-VkPerformanceStreamMarkerInfoINTEL-pNext-pNext
pNext must be NULL

Some applications might want measure the effect of a set of commands with a different settings. It is possible to override a particular settings using :

VkResult vkCmdSetPerformanceOverrideINTEL(
    VkCommandBuffer                             commandBuffer,
    const VkPerformanceOverrideInfoINTEL*       pOverrideInfo);

commandBuffer is the command buffer where the override takes place.
pOverrideInfo is a pointer to a VkPerformanceOverrideInfoINTEL structure selecting the parameter to override.

Valid Usage

VUID-vkCmdSetPerformanceOverrideINTEL-pOverrideInfo-02736
pOverrideInfo must not be used with a VkPerformanceOverrideTypeINTEL that is not reported available by vkGetPerformanceParameterINTEL.

Valid Usage (Implicit)

VUID-vkCmdSetPerformanceOverrideINTEL-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetPerformanceOverrideINTEL-pOverrideInfo-parameter
pOverrideInfo must be a valid pointer to a valid VkPerformanceOverrideInfoINTEL structure
VUID-vkCmdSetPerformanceOverrideINTEL-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetPerformanceOverrideINTEL-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, compute, or transfer operations

Host Synchronization

Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute
Transfer

Return Codes

VK_SUCCESS

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

The VkPerformanceOverrideInfoINTEL structure is defined as:

typedef struct VkPerformanceOverrideInfoINTEL {
    VkStructureType                   sType;
    const void*                       pNext;
    VkPerformanceOverrideTypeINTEL    type;
    VkBool32                          enable;
    uint64_t                          parameter;
} VkPerformanceOverrideInfoINTEL;

type is the particular VkPerformanceOverrideTypeINTEL to set.
enable defines whether the override is enabled.
parameter is a potential required parameter for the override.

Valid Usage (Implicit)

VUID-VkPerformanceOverrideInfoINTEL-sType-sType
sType must be VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL
VUID-VkPerformanceOverrideInfoINTEL-pNext-pNext
pNext must be NULL
VUID-VkPerformanceOverrideInfoINTEL-type-parameter
type must be a valid VkPerformanceOverrideTypeINTEL value

Possible values of VkPerformanceOverrideInfoINTEL::type, specifying performance override types, are:

typedef enum VkPerformanceOverrideTypeINTEL {
    VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0,
    VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1,
    VK_PERFORMANCE_OVERRIDE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
} VkPerformanceOverrideTypeINTEL;

VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL turns all rendering operations into noop.
VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL stalls the stream of commands until all previously emitted commands have completed and all caches been flushed and invalidated.

Before submitting command buffers containing performance queries commands to a device queue, the application must acquire and set a performance query configuration. The configuration can be released once all command buffers containing performance query commands are not in a pending state.

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPerformanceConfigurationINTEL)

To acquire a device performance configuration, call:

VkResult vkAcquirePerformanceConfigurationINTEL(
    VkDevice                                    device,
    const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
    VkPerformanceConfigurationINTEL*            pConfiguration);

device is the logical device that the performance query commands will be submitted to.
pAcquireInfo is a pointer to a VkPerformanceConfigurationAcquireInfoINTEL structure, specifying the performance configuration to acquire.
pConfiguration is a pointer to a VkPerformanceConfigurationINTEL handle in which the resulting configuration object is returned.

Valid Usage (Implicit)

VUID-vkAcquirePerformanceConfigurationINTEL-device-parameter
device must be a valid VkDevice handle
VUID-vkAcquirePerformanceConfigurationINTEL-pAcquireInfo-parameter
pAcquireInfo must be a valid pointer to a valid VkPerformanceConfigurationAcquireInfoINTEL structure
VUID-vkAcquirePerformanceConfigurationINTEL-pConfiguration-parameter
pConfiguration must be a valid pointer to a VkPerformanceConfigurationINTEL handle

Return Codes

VK_SUCCESS

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

The VkPerformanceConfigurationAcquireInfoINTEL structure is defined as:

typedef struct VkPerformanceConfigurationAcquireInfoINTEL {
    VkStructureType                        sType;
    const void*                            pNext;
    VkPerformanceConfigurationTypeINTEL    type;
} VkPerformanceConfigurationAcquireInfoINTEL;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
type is one of the VkPerformanceConfigurationTypeINTEL type of performance configuration that will be acquired.

Valid Usage (Implicit)

VUID-VkPerformanceConfigurationAcquireInfoINTEL-sType-sType
sType must be VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL
VUID-VkPerformanceConfigurationAcquireInfoINTEL-pNext-pNext
pNext must be NULL
VUID-VkPerformanceConfigurationAcquireInfoINTEL-type-parameter
type must be a valid VkPerformanceConfigurationTypeINTEL value

Possible values of VkPerformanceConfigurationAcquireInfoINTEL::type, specifying performance configuration types, are:

typedef enum VkPerformanceConfigurationTypeINTEL {
    VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0,
    VK_PERFORMANCE_CONFIGURATION_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
} VkPerformanceConfigurationTypeINTEL;

To set a performance configuration, call:

VkResult vkQueueSetPerformanceConfigurationINTEL(
    VkQueue                                     queue,
    VkPerformanceConfigurationINTEL             configuration);

queue is the queue on which the configuration will be used.
configuration is the configuration to use.

Valid Usage (Implicit)

VUID-vkQueueSetPerformanceConfigurationINTEL-queue-parameter
queue must be a valid VkQueue handle
VUID-vkQueueSetPerformanceConfigurationINTEL-configuration-parameter
configuration must be a valid VkPerformanceConfigurationINTEL handle
VUID-vkQueueSetPerformanceConfigurationINTEL-commonparent
Both of configuration, and queue must have been created, allocated, or retrieved from the same VkDevice

Command Properties

Any

Return Codes

VK_SUCCESS

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

To release a device performance configuration, call:

VkResult vkReleasePerformanceConfigurationINTEL(
    VkDevice                                    device,
    VkPerformanceConfigurationINTEL             configuration);

device is the device associated to the configuration object to release.
configuration is the configuration object to release.

Valid Usage

VUID-vkReleasePerformanceConfigurationINTEL-configuration-02737
configuration must not be released before all command buffers submitted while the configuration was set are in pending state.

Valid Usage (Implicit)

VUID-vkReleasePerformanceConfigurationINTEL-device-parameter
device must be a valid VkDevice handle
VUID-vkReleasePerformanceConfigurationINTEL-configuration-parameter
configuration must be a valid VkPerformanceConfigurationINTEL handle
VUID-vkReleasePerformanceConfigurationINTEL-configuration-parent
configuration must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

18. Clear Commands

18.1. Clearing Images Outside A Render Pass Instance

Color and depth/stencil images can be cleared outside a render pass instance using vkCmdClearColorImage or vkCmdClearDepthStencilImage, respectively. These commands are only allowed outside of a render pass instance.

To clear one or more subranges of a color image, call:

void vkCmdClearColorImage(
    VkCommandBuffer                             commandBuffer,
    VkImage                                     image,
    VkImageLayout                               imageLayout,
    const VkClearColorValue*                    pColor,
    uint32_t                                    rangeCount,
    const VkImageSubresourceRange*              pRanges);

commandBuffer is the command buffer into which the command will be recorded.
image is the image to be cleared.
imageLayout specifies the current layout of the image subresource ranges to be cleared, and must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_GENERAL or VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL.
pColor is a pointer to a VkClearColorValue structure containing the values that the image subresource ranges will be cleared to (see Clear Values below).
rangeCount is the number of image subresource range structures in pRanges.
pRanges is a pointer to an array of VkImageSubresourceRange structures describing a range of mipmap levels, array layers, and aspects to be cleared, as described in Image Views.

Each specified range in pRanges is cleared to the value specified by pColor.

Valid Usage

VUID-vkCmdClearColorImage-image-01993
The format features of image must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT.
VUID-vkCmdClearColorImage-image-00002
image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag
VUID-vkCmdClearColorImage-image-01545
image must not use a format listed in Formats requiring sampler Y′C_BC_R conversion for VK_IMAGE_ASPECT_COLOR_BIT image views
VUID-vkCmdClearColorImage-image-00003
If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdClearColorImage-imageLayout-00004
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
VUID-vkCmdClearColorImage-imageLayout-01394
imageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR
VUID-vkCmdClearColorImage-aspectMask-02498
The VkImageSubresourceRange::aspectMask members of the elements of the pRanges array must each only include VK_IMAGE_ASPECT_COLOR_BIT
VUID-vkCmdClearColorImage-baseMipLevel-01470
The VkImageSubresourceRange::baseMipLevel members of the elements of the pRanges array must each be less than the mipLevels specified in VkImageCreateInfo when image was created
VUID-vkCmdClearColorImage-pRanges-01692
For each VkImageSubresourceRange element of pRanges, if the levelCount member is not VK_REMAINING_MIP_LEVELS, then baseMipLevel + levelCount must be less than the mipLevels specified in VkImageCreateInfo when image was created
VUID-vkCmdClearColorImage-baseArrayLayer-01472
The VkImageSubresourceRange::baseArrayLayer members of the elements of the pRanges array must each be less than the arrayLayers specified in VkImageCreateInfo when image was created
VUID-vkCmdClearColorImage-pRanges-01693
For each VkImageSubresourceRange element of pRanges, if the layerCount member is not VK_REMAINING_ARRAY_LAYERS, then baseArrayLayer + layerCount must be less than the arrayLayers specified in VkImageCreateInfo when image was created
VUID-vkCmdClearColorImage-image-00007
image must not have a compressed or depth/stencil format
VUID-vkCmdClearColorImage-commandBuffer-01805
If commandBuffer is an unprotected command buffer, then image must not be a protected image
VUID-vkCmdClearColorImage-commandBuffer-01806
If commandBuffer is a protected command buffer, then image must not be an unprotected image

Valid Usage (Implicit)

VUID-vkCmdClearColorImage-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdClearColorImage-image-parameter
image must be a valid VkImage handle
VUID-vkCmdClearColorImage-imageLayout-parameter
imageLayout must be a valid VkImageLayout value
VUID-vkCmdClearColorImage-pColor-parameter
pColor must be a valid pointer to a valid VkClearColorValue union
VUID-vkCmdClearColorImage-pRanges-parameter
pRanges must be a valid pointer to an array of rangeCount valid VkImageSubresourceRange structures
VUID-vkCmdClearColorImage-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdClearColorImage-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
VUID-vkCmdClearColorImage-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdClearColorImage-rangeCount-arraylength
rangeCount must be greater than 0
VUID-vkCmdClearColorImage-commonparent
Both of commandBuffer, and image must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Graphics
Compute

Transfer

To clear one or more subranges of a depth/stencil image, call:

void vkCmdClearDepthStencilImage(
    VkCommandBuffer                             commandBuffer,
    VkImage                                     image,
    VkImageLayout                               imageLayout,
    const VkClearDepthStencilValue*             pDepthStencil,
    uint32_t                                    rangeCount,
    const VkImageSubresourceRange*              pRanges);

commandBuffer is the command buffer into which the command will be recorded.
image is the image to be cleared.
imageLayout specifies the current layout of the image subresource ranges to be cleared, and must be VK_IMAGE_LAYOUT_GENERAL or VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL.
pDepthStencil is a pointer to a VkClearDepthStencilValue structure containing the values that the depth and stencil image subresource ranges will be cleared to (see Clear Values below).
rangeCount is the number of image subresource range structures in pRanges.
pRanges is a pointer to an array of VkImageSubresourceRange structures describing a range of mipmap levels, array layers, and aspects to be cleared, as described in Image Views.

Valid Usage

VUID-vkCmdClearDepthStencilImage-image-01994
The format features of image must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT.
VUID-vkCmdClearDepthStencilImage-pRanges-02658
If any element of pRanges.aspect includes VK_IMAGE_ASPECT_STENCIL_BIT, and image was created with separate stencil usage, VK_IMAGE_USAGE_TRANSFER_DST_BIT must have been included in the VkImageStencilUsageCreateInfo::stencilUsage used to create image
VUID-vkCmdClearDepthStencilImage-pRanges-02659
If any element of pRanges.aspect includes VK_IMAGE_ASPECT_STENCIL_BIT, and image was not created with separate stencil usage, VK_IMAGE_USAGE_TRANSFER_DST_BIT must have been included in the VkImageCreateInfo::usage used to create image
VUID-vkCmdClearDepthStencilImage-pRanges-02660
If any element of pRanges.aspect includes VK_IMAGE_ASPECT_DEPTH_BIT, VK_IMAGE_USAGE_TRANSFER_DST_BIT must have been included in the VkImageCreateInfo::usage used to create image
VUID-vkCmdClearDepthStencilImage-image-00010
If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdClearDepthStencilImage-imageLayout-00011
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
VUID-vkCmdClearDepthStencilImage-imageLayout-00012
imageLayout must be either of VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
VUID-vkCmdClearDepthStencilImage-aspectMask-02824
The VkImageSubresourceRange::aspectMask member of each element of the pRanges array must not include bits other than VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT
VUID-vkCmdClearDepthStencilImage-image-02825
If the image’s format does not have a stencil component, then the VkImageSubresourceRange::aspectMask member of each element of the pRanges array must not include the VK_IMAGE_ASPECT_STENCIL_BIT bit
VUID-vkCmdClearDepthStencilImage-image-02826
If the image’s format does not have a depth component, then the VkImageSubresourceRange::aspectMask member of each element of the pRanges array must not include the VK_IMAGE_ASPECT_DEPTH_BIT bit
VUID-vkCmdClearDepthStencilImage-baseMipLevel-01474
The VkImageSubresourceRange::baseMipLevel members of the elements of the pRanges array must each be less than the mipLevels specified in VkImageCreateInfo when image was created
VUID-vkCmdClearDepthStencilImage-pRanges-01694
For each VkImageSubresourceRange element of pRanges, if the levelCount member is not VK_REMAINING_MIP_LEVELS, then baseMipLevel + levelCount must be less than the mipLevels specified in VkImageCreateInfo when image was created
VUID-vkCmdClearDepthStencilImage-baseArrayLayer-01476
The VkImageSubresourceRange::baseArrayLayer members of the elements of the pRanges array must each be less than the arrayLayers specified in VkImageCreateInfo when image was created
VUID-vkCmdClearDepthStencilImage-pRanges-01695
For each VkImageSubresourceRange element of pRanges, if the layerCount member is not VK_REMAINING_ARRAY_LAYERS, then baseArrayLayer + layerCount must be less than the arrayLayers specified in VkImageCreateInfo when image was created
VUID-vkCmdClearDepthStencilImage-image-00014
image must have a depth/stencil format
VUID-vkCmdClearDepthStencilImage-commandBuffer-01807
If commandBuffer is an unprotected command buffer, then image must not be a protected image
VUID-vkCmdClearDepthStencilImage-commandBuffer-01808
If commandBuffer is a protected command buffer, then image must not be an unprotected image

Valid Usage (Implicit)

VUID-vkCmdClearDepthStencilImage-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdClearDepthStencilImage-image-parameter
image must be a valid VkImage handle
VUID-vkCmdClearDepthStencilImage-imageLayout-parameter
imageLayout must be a valid VkImageLayout value
VUID-vkCmdClearDepthStencilImage-pDepthStencil-parameter
pDepthStencil must be a valid pointer to a valid VkClearDepthStencilValue structure
VUID-vkCmdClearDepthStencilImage-pRanges-parameter
pRanges must be a valid pointer to an array of rangeCount valid VkImageSubresourceRange structures
VUID-vkCmdClearDepthStencilImage-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdClearDepthStencilImage-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdClearDepthStencilImage-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdClearDepthStencilImage-rangeCount-arraylength
rangeCount must be greater than 0
VUID-vkCmdClearDepthStencilImage-commonparent
Both of commandBuffer, and image must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Graphics

Transfer

Clears outside render pass instances are treated as transfer operations for the purposes of memory barriers.

18.2. Clearing Images Inside A Render Pass Instance

To clear one or more regions of color and depth/stencil attachments inside a render pass instance, call:

void vkCmdClearAttachments(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    attachmentCount,
    const VkClearAttachment*                    pAttachments,
    uint32_t                                    rectCount,
    const VkClearRect*                          pRects);

commandBuffer is the command buffer into which the command will be recorded.
attachmentCount is the number of entries in the pAttachments array.
pAttachments is a pointer to an array of VkClearAttachment structures defining the attachments to clear and the clear values to use. If any attachment to be cleared in the current subpass is VK_ATTACHMENT_UNUSED, then the clear has no effect on that attachment.
rectCount is the number of entries in the pRects array.
pRects is a pointer to an array of VkClearRect structures defining regions within each selected attachment to clear.

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.

If the render pass has a fragment density map attachment, clears follow the operations of fragment density maps as if each clear region was a primitive which generates fragments. The clear color is applied to all pixels inside each fragment’s area regardless if the pixels lie outside of the clear region. Clears may have a different set of supported fragment areas than draws.

Unlike other clear commands, vkCmdClearAttachments executes as a drawing command, rather than a transfer command, with writes performed by it executing in rasterization order. Clears to color attachments are executed as color attachment writes, by the VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT stage. Clears to depth/stencil attachments are executed as depth writes and writes by the VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT and VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT stages.

Valid Usage

VUID-vkCmdClearAttachments-aspectMask-02501
If the aspectMask member of any element of pAttachments contains VK_IMAGE_ASPECT_COLOR_BIT, then the colorAttachment member of that element must either refer to a color attachment which is VK_ATTACHMENT_UNUSED, or must be a valid color attachment.
VUID-vkCmdClearAttachments-aspectMask-02502
If the aspectMask member of any element of pAttachments contains VK_IMAGE_ASPECT_DEPTH_BIT, then the current subpass' depth/stencil attachment must either be VK_ATTACHMENT_UNUSED, or must have a depth component
VUID-vkCmdClearAttachments-aspectMask-02503
If the aspectMask member of any element of pAttachments contains VK_IMAGE_ASPECT_STENCIL_BIT, then the current subpass' depth/stencil attachment must either be VK_ATTACHMENT_UNUSED, or must have a stencil component
VUID-vkCmdClearAttachments-rect-02682
The rect member of each element of pRects must have an extent.width greater than 0
VUID-vkCmdClearAttachments-rect-02683
The rect member of each element of pRects must have an extent.height greater than 0
VUID-vkCmdClearAttachments-pRects-00016
The rectangular region specified by each element of pRects must be contained within the render area of the current render pass instance
VUID-vkCmdClearAttachments-pRects-00017
The layers specified by each element of pRects must be contained within every attachment that pAttachments refers to
VUID-vkCmdClearAttachments-layerCount-01934
The layerCount member of each element of pRects must not be 0
VUID-vkCmdClearAttachments-commandBuffer-02504
If commandBuffer is an unprotected command buffer, then each attachment to be cleared must not be a protected image.
VUID-vkCmdClearAttachments-commandBuffer-02505
If commandBuffer is a protected command buffer, then each attachment to be cleared must not be an unprotected image.
VUID-vkCmdClearAttachments-baseArrayLayer-00018
If the render pass instance this is recorded in uses multiview, then baseArrayLayer must be zero and layerCount must be one.

Valid Usage (Implicit)

VUID-vkCmdClearAttachments-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdClearAttachments-pAttachments-parameter
pAttachments must be a valid pointer to an array of attachmentCount valid VkClearAttachment structures
VUID-vkCmdClearAttachments-pRects-parameter
pRects must be a valid pointer to an array of rectCount VkClearRect structures
VUID-vkCmdClearAttachments-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdClearAttachments-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdClearAttachments-renderpass
This command must only be called inside of a render pass instance
VUID-vkCmdClearAttachments-attachmentCount-arraylength
attachmentCount must be greater than 0
VUID-vkCmdClearAttachments-rectCount-arraylength
rectCount must be greater than 0

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Inside

Graphics

The VkClearRect structure is defined as:

typedef struct VkClearRect {
    VkRect2D    rect;
    uint32_t    baseArrayLayer;
    uint32_t    layerCount;
} VkClearRect;

rect is the two-dimensional region to be cleared.
baseArrayLayer is the first layer to be cleared.
layerCount is the number of layers to clear.

The layers [baseArrayLayer, baseArrayLayer + layerCount) counting from the base layer of the attachment image view are cleared.

The VkClearAttachment structure is defined as:

typedef struct VkClearAttachment {
    VkImageAspectFlags    aspectMask;
    uint32_t              colorAttachment;
    VkClearValue          clearValue;
} VkClearAttachment;

aspectMask is a mask selecting the color, depth and/or stencil aspects of the attachment to be cleared.
colorAttachment is only meaningful if VK_IMAGE_ASPECT_COLOR_BIT is set in aspectMask, in which case it is an index to the pColorAttachments array in the VkSubpassDescription structure of the current subpass which selects the color attachment to clear.
clearValue is the color or depth/stencil value to clear the attachment to, as described in Clear Values below.

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 VK_ATTACHMENT_LOAD_OP_CLEAR, as described for vkCreateRenderPass.

Valid Usage

VUID-VkClearAttachment-aspectMask-00019
If aspectMask includes VK_IMAGE_ASPECT_COLOR_BIT, it must not include VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT
VUID-VkClearAttachment-aspectMask-00020
aspectMask must not include VK_IMAGE_ASPECT_METADATA_BIT
VUID-VkClearAttachment-aspectMask-02246
aspectMask must not include VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT for any index i.
VUID-VkClearAttachment-clearValue-00021
clearValue must be a valid VkClearValue union

Valid Usage (Implicit)

VUID-VkClearAttachment-aspectMask-parameter
aspectMask must be a valid combination of VkImageAspectFlagBits values
VUID-VkClearAttachment-aspectMask-requiredbitmask
aspectMask must not be 0

18.3. Clear Values

The VkClearColorValue structure is defined as:

typedef union VkClearColorValue {
    float       float32[4];
    int32_t     int32[4];
    uint32_t    uint32[4];
} VkClearColorValue;

float32 are the color clear values when the format of the image or attachment is one of the formats in the Interpretation of Numeric Format table other than signed integer (SINT) or unsigned integer (UINT). Floating point values are automatically converted to the format of the image, with the clear value being treated as linear if the image is sRGB.
int32 are the color clear values when the format of the image or attachment is signed integer (SINT). Signed integer values are converted to the format of the image by casting to the smaller type (with negative 32-bit values mapping to negative values in the smaller type). If the integer clear value is not representable in the target type (e.g. would overflow in conversion to that type), the clear value is undefined.
uint32 are the color clear values when the format of the image or attachment is unsigned integer (UINT). Unsigned integer values are converted to the format of the image by casting to the integer type with fewer bits.

The four array elements of the clear color map to R, G, B, and A components of image formats, in order.

If the image has more than one sample, the same value is written to all samples for any pixels being cleared.

The VkClearDepthStencilValue structure is defined as:

typedef struct VkClearDepthStencilValue {
    float       depth;
    uint32_t    stencil;
} VkClearDepthStencilValue;

depth is the clear value for the depth aspect of the depth/stencil attachment. It is a floating-point value which is automatically converted to the attachment’s format.
stencil is the clear value for the stencil aspect of the depth/stencil attachment. It is a 32-bit integer value which is converted to the attachment’s format by taking the appropriate number of LSBs.

Valid Usage

VUID-VkClearDepthStencilValue-depth-00022
Unless the VK_EXT_depth_range_unrestricted extension is enabled depth must be between 0.0 and 1.0, inclusive

The VkClearValue union is defined as:

typedef union VkClearValue {
    VkClearColorValue           color;
    VkClearDepthStencilValue    depthStencil;
} VkClearValue;

color specifies the color image clear values to use when clearing a color image or attachment.
depthStencil specifies the depth and stencil clear values to use when clearing a depth/stencil image or attachment.

This union is used where part of the API requires either color or depth/stencil clear values, depending on the attachment, and defines the initial clear values in the VkRenderPassBeginInfo structure.

18.4. Filling Buffers

To clear buffer data, call:

void vkCmdFillBuffer(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    dstBuffer,
    VkDeviceSize                                dstOffset,
    VkDeviceSize                                size,
    uint32_t                                    data);

commandBuffer is the command buffer into which the command will be recorded.
dstBuffer is the buffer to be filled.
dstOffset is the byte offset into the buffer at which to start filling, and must be a multiple of 4.
size is the number of bytes to fill, and must be either a multiple of 4, or VK_WHOLE_SIZE to fill the range from offset to the end of the buffer. If VK_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 is 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.

vkCmdFillBuffer is treated as “transfer” operation for the purposes of synchronization barriers. The VK_BUFFER_USAGE_TRANSFER_DST_BIT must be specified in usage of VkBufferCreateInfo in order for the buffer to be compatible with vkCmdFillBuffer.

Valid Usage

VUID-vkCmdFillBuffer-dstOffset-00024
dstOffset must be less than the size of dstBuffer
VUID-vkCmdFillBuffer-dstOffset-00025
dstOffset must be a multiple of 4
VUID-vkCmdFillBuffer-size-00026
If size is not equal to VK_WHOLE_SIZE, size must be greater than 0
VUID-vkCmdFillBuffer-size-00027
If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to the size of dstBuffer minus dstOffset
VUID-vkCmdFillBuffer-size-00028
If size is not equal to VK_WHOLE_SIZE, size must be a multiple of 4
VUID-vkCmdFillBuffer-dstBuffer-00029
dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag
VUID-vkCmdFillBuffer-dstBuffer-00031
If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdFillBuffer-commandBuffer-01811
If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer
VUID-vkCmdFillBuffer-commandBuffer-01812
If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer

Valid Usage (Implicit)

VUID-vkCmdFillBuffer-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdFillBuffer-dstBuffer-parameter
dstBuffer must be a valid VkBuffer handle
VUID-vkCmdFillBuffer-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdFillBuffer-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support transfer, graphics or compute operations
VUID-vkCmdFillBuffer-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdFillBuffer-commonparent
Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Transfer
Graphics
Compute

Transfer

18.5. Updating Buffers

To update buffer data inline in a command buffer, call:

void vkCmdUpdateBuffer(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    dstBuffer,
    VkDeviceSize                                dstOffset,
    VkDeviceSize                                dataSize,
    const void*                                 pData);

commandBuffer is the command buffer into which the command will be recorded.
dstBuffer is a handle to the buffer to be updated.
dstOffset is the byte offset into the buffer to start updating, and must be a multiple of 4.
dataSize is the number of bytes to update, and must be a multiple of 4.
pData is a pointer to the source data for the buffer update, and must be at least dataSize bytes in size.

dataSize must be less than or equal to 65536 bytes. For larger updates, applications can use buffer to buffer copies.

Note

Buffer updates performed with vkCmdUpdateBuffer first copy the data into command buffer memory when the command is recorded (which requires additional storage and may incur an additional allocation), and then copy the data from the command buffer into dstBuffer when the command is executed on a device.

The additional cost of this functionality compared to buffer to buffer copies means it is only recommended for very small amounts of data, and is why it is limited to only 65536 bytes.

Applications can work around this by issuing multiple vkCmdUpdateBuffer commands to different ranges of the same buffer, but it is strongly recommended that they should not.

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 VK_BUFFER_USAGE_TRANSFER_DST_BIT must be specified in usage of VkBufferCreateInfo in order for the buffer to be compatible with vkCmdUpdateBuffer.

Valid Usage

VUID-vkCmdUpdateBuffer-dstOffset-00032
dstOffset must be less than the size of dstBuffer
VUID-vkCmdUpdateBuffer-dataSize-00033
dataSize must be less than or equal to the size of dstBuffer minus dstOffset
VUID-vkCmdUpdateBuffer-dstBuffer-00034
dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag
VUID-vkCmdUpdateBuffer-dstBuffer-00035
If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdUpdateBuffer-dstOffset-00036
dstOffset must be a multiple of 4
VUID-vkCmdUpdateBuffer-dataSize-00037
dataSize must be less than or equal to 65536
VUID-vkCmdUpdateBuffer-dataSize-00038
dataSize must be a multiple of 4
VUID-vkCmdUpdateBuffer-commandBuffer-01813
If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer
VUID-vkCmdUpdateBuffer-commandBuffer-01814
If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer

Valid Usage (Implicit)

VUID-vkCmdUpdateBuffer-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdUpdateBuffer-dstBuffer-parameter
dstBuffer must be a valid VkBuffer handle
VUID-vkCmdUpdateBuffer-pData-parameter
pData must be a valid pointer to an array of dataSize bytes
VUID-vkCmdUpdateBuffer-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdUpdateBuffer-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations
VUID-vkCmdUpdateBuffer-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdUpdateBuffer-dataSize-arraylength
dataSize must be greater than 0
VUID-vkCmdUpdateBuffer-commonparent
Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Transfer
Graphics
Compute

Transfer

Note

The pData parameter was of type uint32_t* instead of void* prior to version 1.0.19 of the Specification and VK_HEADER_VERSION 19 of the Vulkan Header Files. This was a historical anomaly, as the source data may be of other types.

19. Copy Commands

An application can copy buffer and image data using several methods depending on the type of data transfer. Data can be copied between buffer objects with vkCmdCopyBuffer and a portion of an image can be copied to another image with vkCmdCopyImage. Image data can also be copied to and from buffer memory using vkCmdCopyImageToBuffer and vkCmdCopyBufferToImage. Image data can be blitted (with or without scaling and filtering) with vkCmdBlitImage. Multisampled images can be resolved to a non-multisampled image with vkCmdResolveImage.

19.1. Common Operation

The following valid usage rules apply to all copy commands:

Copy commands must be recorded outside of a render pass instance.
The set of all bytes bound to all the source regions must not overlap the set of all bytes bound to the destination regions.
The set of all bytes bound to each destination region must not overlap the set of all bytes bound to another destination region.
Copy regions must be non-empty.
Regions must not extend outside the bounds of the buffer or image level, except that regions of compressed images can extend as far as the dimension of the image level rounded up to a complete compressed texel block.
Source image subresources must be in either the VK_IMAGE_LAYOUT_GENERAL or VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL layout. Destination image subresources must be in the VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_GENERAL or VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL layout. As a consequence, if an image subresource is used as both source and destination of a copy, it must be in the VK_IMAGE_LAYOUT_GENERAL layout.
Source images must have VK_FORMAT_FEATURE_TRANSFER_SRC_BIT in their format features.
Destination images must have VK_FORMAT_FEATURE_TRANSFER_DST_BIT in their format features.
Source buffers must have been created with the VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage bit enabled and destination buffers must have been created with the VK_BUFFER_USAGE_TRANSFER_DST_BIT usage bit enabled.
If the stencil aspect of source image is accessed, and the source image was not created with separate stencil usage, the source image must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT set in VkImageCreateInfo::usage
If the stencil aspect of destination image is accessed, and the destination image was not created with separate stencil usage, the destination image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT set in VkImageCreateInfo::usage
If the stencil aspect of source image is accessed, and the source image was created with separate stencil usage, the source image must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT set in VkImageStencilUsageCreateInfo::stencilUsage
If the stencil aspect of destination image is accessed, and the destination image was created with separate stencil usage, the destination image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT set in VkImageStencilUsageCreateInfo::stencilUsage
If non-stencil aspects of a source image are accessed, the source image must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT set in VkImageCreateInfo::usage
If non-stencil aspects of a source image are accessed, the source image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT set in VkImageCreateInfo::usage

All copy commands are treated as “transfer” operations for the purposes of synchronization barriers.

19.2. Copying Data Between Buffers

To copy data between buffer objects, call:

void vkCmdCopyBuffer(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    srcBuffer,
    VkBuffer                                    dstBuffer,
    uint32_t                                    regionCount,
    const VkBufferCopy*                         pRegions);

commandBuffer is the command buffer into which the command will be recorded.
srcBuffer is the source buffer.
dstBuffer is the destination buffer.
regionCount is the number of regions to copy.
pRegions is a pointer to an array of VkBufferCopy structures specifying the regions to copy.

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 resulting values are undefined if the copy regions overlap in memory.

Valid Usage

VUID-vkCmdCopyBuffer-srcOffset-00113
The srcOffset member of each element of pRegions must be less than the size of srcBuffer
VUID-vkCmdCopyBuffer-dstOffset-00114
The dstOffset member of each element of pRegions must be less than the size of dstBuffer
VUID-vkCmdCopyBuffer-size-00115
The size member of each element of pRegions must be less than or equal to the size of srcBuffer minus srcOffset
VUID-vkCmdCopyBuffer-size-00116
The size member of each element of pRegions must be less than or equal to the size of dstBuffer minus dstOffset
VUID-vkCmdCopyBuffer-pRegions-00117
The union of the source regions, and the union of the destination regions, specified by the elements of pRegions, must not overlap in memory
VUID-vkCmdCopyBuffer-srcBuffer-00118
srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag
VUID-vkCmdCopyBuffer-srcBuffer-00119
If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdCopyBuffer-dstBuffer-00120
dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag
VUID-vkCmdCopyBuffer-dstBuffer-00121
If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdCopyBuffer-commandBuffer-01822
If commandBuffer is an unprotected command buffer, then srcBuffer must not be a protected buffer
VUID-vkCmdCopyBuffer-commandBuffer-01823
If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer
VUID-vkCmdCopyBuffer-commandBuffer-01824
If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer

Valid Usage (Implicit)

VUID-vkCmdCopyBuffer-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdCopyBuffer-srcBuffer-parameter
srcBuffer must be a valid VkBuffer handle
VUID-vkCmdCopyBuffer-dstBuffer-parameter
dstBuffer must be a valid VkBuffer handle
VUID-vkCmdCopyBuffer-pRegions-parameter
pRegions must be a valid pointer to an array of regionCount valid VkBufferCopy structures
VUID-vkCmdCopyBuffer-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdCopyBuffer-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations
VUID-vkCmdCopyBuffer-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdCopyBuffer-regionCount-arraylength
regionCount must be greater than 0
VUID-vkCmdCopyBuffer-commonparent
Each of commandBuffer, dstBuffer, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Transfer
Graphics
Compute

Transfer

The VkBufferCopy structure is defined as:

typedef struct VkBufferCopy {
    VkDeviceSize    srcOffset;
    VkDeviceSize    dstOffset;
    VkDeviceSize    size;
} VkBufferCopy;

srcOffset is the starting offset in bytes from the start of srcBuffer.
dstOffset is the starting offset in bytes from the start of dstBuffer.
size is the number of bytes to copy.

Valid Usage

VUID-VkBufferCopy-size-01988
The size must be greater than 0

19.3. Copying Data Between Images

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 as defined below.

To copy data between image objects, call:

void vkCmdCopyImage(
    VkCommandBuffer                             commandBuffer,
    VkImage                                     srcImage,
    VkImageLayout                               srcImageLayout,
    VkImage                                     dstImage,
    VkImageLayout                               dstImageLayout,
    uint32_t                                    regionCount,
    const VkImageCopy*                          pRegions);

commandBuffer is the command buffer into which the command will be recorded.
srcImage is the source image.
srcImageLayout is the current layout of the source image subresource.
dstImage is the destination image.
dstImageLayout is the current layout of the destination image subresource.
regionCount is the number of regions to copy.
pRegions is a pointer to an array of VkImageCopy structures specifying the regions to copy.

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.

The formats of srcImage and dstImage must be compatible. Formats are compatible if they share the same class, as shown in the Compatible Formats table. Depth/stencil formats must match exactly.

If the format of srcImage or dstImage is a multi-planar image format, regions of each plane to be copied must be specified separately using the srcSubresource and dstSubresource members of the VkImageCopy structure. In this case, the aspectMask of the srcSubresource or dstSubresource that refers to the multi-planar image must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT. For the purposes of vkCmdCopyImage, each plane of a multi-planar image is treated as having the format listed in Compatible formats of planes of multi-planar formats for the plane identified by the aspectMask of the corresponding subresource. This applies both to VkFormat and to coordinates used in the copy, which correspond to texels in the plane rather than how these texels map to coordinates in the image as a whole.

Note

For example, the VK_IMAGE_ASPECT_PLANE_1_BIT plane of a VK_FORMAT_G8_B8R8_2PLANE_420_UNORM image is compatible with an image of format VK_FORMAT_R8G8_UNORM and (less usefully) with the VK_IMAGE_ASPECT_PLANE_0_BIT plane of an image of format VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, as each texel is 2 bytes in size.

vkCmdCopyImage allows copying between size-compatible compressed and uncompressed internal formats. Formats are size-compatible if the texel block size of the uncompressed format is equal to the texel block size 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 of the source image is copied as a raw value to the corresponding compressed texel block of the destination image. When copying from a compressed format to an uncompressed format, each compressed texel block of the source image is copied as a raw value to the corresponding texel of uncompressed data in the destination image. Thus, for example, it is legal to copy between a 128-bit uncompressed format and a compressed format which has a 128-bit sized compressed texel block representing 4×4 texels (using 8 bits per texel), or between a 64-bit uncompressed format and a compressed format which has a 64-bit sized compressed texel block representing 4×4 texels (using 4 bits per texel).

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 compressed texel block dimensions. 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 compressed texel block dimensions. 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 compressed texel block size. For this reason the extent must be a multiple of the compressed texel 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 compressed texel block dimensions: if the srcImage is compressed, then:

If extent.width is not a multiple of the compressed texel block width, then (extent.width + srcOffset.x) must equal the image subresource width.
If extent.height is not a multiple of the compressed texel block height, then (extent.height + srcOffset.y) must equal the image subresource height.
If extent.depth is not a multiple of the compressed texel block depth, then (extent.depth + srcOffset.z) must equal the image subresource depth.

Similarly, if the dstImage is compressed, then:

If extent.width is not a multiple of the compressed texel block width, then (extent.width + dstOffset.x) must equal the image subresource width.
If extent.height is not a multiple of the compressed texel block height, then (extent.height + dstOffset.y) must equal the image subresource height.
If extent.depth is not a multiple of the compressed texel block depth, then (extent.depth + dstOffset.z) must equal the image subresource depth.

This allows the last compressed texel block of the image in each non-multiple dimension to be included as a source or destination of the copy.

“_422” image formats that are not multi-planar are treated as having a 2×1 compressed texel block for the purposes of these rules.

vkCmdCopyImage can be used to copy image data between multisample images, but both images must have the same number of samples.

Valid Usage

VUID-vkCmdCopyImage-pRegions-00122
The source region specified by each element of pRegions must be a region that is contained within srcImage if the srcImage’s VkFormat is not a multi-planar format, and must be a region that is contained within the plane being copied if the srcImage’s VkFormat is a multi-planar format
VUID-vkCmdCopyImage-pRegions-00123
The destination region specified by each element of pRegions must be a region that is contained within dstImage if the dstImage’s VkFormat is not a multi-planar format, and must be a region that is contained within the plane being copied to if the dstImage’s VkFormat is a multi-planar format
VUID-vkCmdCopyImage-pRegions-00124
The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory
VUID-vkCmdCopyImage-srcImage-01995
The format features of srcImage must contain VK_FORMAT_FEATURE_TRANSFER_SRC_BIT.
VUID-vkCmdCopyImage-srcImage-00126
srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag
VUID-vkCmdCopyImage-srcImage-01546
If srcImage is non-sparse then the image or disjoint plane to be copied must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdCopyImage-srcImageLayout-00128
srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice
VUID-vkCmdCopyImage-srcImageLayout-01917
srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR
VUID-vkCmdCopyImage-dstImage-01996
The format features of dstImage must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT.
VUID-vkCmdCopyImage-dstImage-00131
dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag
VUID-vkCmdCopyImage-dstImage-01547
If dstImage is non-sparse then the image or disjoint plane that is the destination of the copy must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdCopyImage-dstImageLayout-00133
dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice
VUID-vkCmdCopyImage-dstImageLayout-01395
dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR
VUID-vkCmdCopyImage-srcImage-01548
If the VkFormat of each of srcImage and dstImage is not a multi-planar format, the VkFormat of each of srcImage and dstImage must be compatible, as defined above
VUID-vkCmdCopyImage-None-01549
In a copy to or from a plane of a multi-planar image, the VkFormat of the image and plane must be compatible according to the description of compatible planes for the plane being copied
VUID-vkCmdCopyImage-aspectMask-01550
When a copy is performed to or from an image with a multi-planar format, the aspectMask of the srcSubresource and/or dstSubresource that refers to the multi-planar image must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT (with VK_IMAGE_ASPECT_PLANE_2_BIT valid only for a VkFormat with three planes)
VUID-vkCmdCopyImage-srcImage-00136
The sample count of srcImage and dstImage must match
VUID-vkCmdCopyImage-commandBuffer-01825
If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image
VUID-vkCmdCopyImage-commandBuffer-01826
If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image
VUID-vkCmdCopyImage-commandBuffer-01827
If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image
VUID-vkCmdCopyImage-srcSubresource-01696
The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created
VUID-vkCmdCopyImage-dstSubresource-01697
The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created
VUID-vkCmdCopyImage-srcSubresource-01698
The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created
VUID-vkCmdCopyImage-dstSubresource-01699
The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created
VUID-vkCmdCopyImage-srcOffset-01783
The srcOffset and extent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties
VUID-vkCmdCopyImage-dstOffset-01784
The dstOffset and extent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties
VUID-vkCmdCopyImage-dstImage-02542
dstImage and srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT

Valid Usage (Implicit)

VUID-vkCmdCopyImage-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdCopyImage-srcImage-parameter
srcImage must be a valid VkImage handle
VUID-vkCmdCopyImage-srcImageLayout-parameter
srcImageLayout must be a valid VkImageLayout value
VUID-vkCmdCopyImage-dstImage-parameter
dstImage must be a valid VkImage handle
VUID-vkCmdCopyImage-dstImageLayout-parameter
dstImageLayout must be a valid VkImageLayout value
VUID-vkCmdCopyImage-pRegions-parameter
pRegions must be a valid pointer to an array of regionCount valid VkImageCopy structures
VUID-vkCmdCopyImage-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdCopyImage-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations
VUID-vkCmdCopyImage-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdCopyImage-regionCount-arraylength
regionCount must be greater than 0
VUID-vkCmdCopyImage-commonparent
Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Transfer
Graphics
Compute

Transfer

The VkImageCopy structure is defined as:

typedef struct VkImageCopy {
    VkImageSubresourceLayers    srcSubresource;
    VkOffset3D                  srcOffset;
    VkImageSubresourceLayers    dstSubresource;
    VkOffset3D                  dstOffset;
    VkExtent3D                  extent;
} VkImageCopy;

srcSubresource and dstSubresource are VkImageSubresourceLayers structures specifying the image subresources of the images used for the source and destination image data, respectively.
srcOffset and dstOffset select the initial x, y, and z offsets in texels of the sub-regions of the source and destination image data.
extent is the size in texels of the image to copy in width, height and depth.

For VK_IMAGE_TYPE_3D images, copies are performed slice by slice starting with the z member of the srcOffset or dstOffset, and copying depth slices. For images with multiple layers, copies are performed layer by layer starting with the baseArrayLayer member of the srcSubresource or dstSubresource and copying layerCount layers. Image data can be copied between images with different image types. If one image is VK_IMAGE_TYPE_3D and the other image is VK_IMAGE_TYPE_2D with multiple layers, then each slice is copied to or from a different layer.

Copies involving a multi-planar image format specify the region to be copied in terms of the plane to be copied, not the coordinates of the multi-planar image. This means that copies accessing the R/B planes of “_422” format images must fit the copied region within half the width of the parent image, and that copies accessing the R/B planes of “_420” format images must fit the copied region within half the width and height of the parent image.

Valid Usage

VUID-VkImageCopy-srcImage-01551
If neither the calling command’s srcImage nor the calling command’s dstImage has a multi-planar image format then the aspectMask member of srcSubresource and dstSubresource must match
VUID-VkImageCopy-srcImage-01552
If the calling command’s srcImage has a VkFormat with two planes then the srcSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT
VUID-VkImageCopy-srcImage-01553
If the calling command’s srcImage has a VkFormat with three planes then the srcSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT
VUID-VkImageCopy-dstImage-01554
If the calling command’s dstImage has a VkFormat with two planes then the dstSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT
VUID-VkImageCopy-dstImage-01555
If the calling command’s dstImage has a VkFormat with three planes then the dstSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT
VUID-VkImageCopy-srcImage-01556
If the calling command’s srcImage has a multi-planar image format and the dstImage does not have a multi-planar image format, the dstSubresource aspectMask must be VK_IMAGE_ASPECT_COLOR_BIT
VUID-VkImageCopy-dstImage-01557
If the calling command’s dstImage has a multi-planar image format and the srcImage does not have a multi-planar image format, the srcSubresource aspectMask must be VK_IMAGE_ASPECT_COLOR_BIT
VUID-VkImageCopy-extent-00140
The number of slices of the extent (for 3D) or layers of the srcSubresource (for non-3D) must match the number of slices of the extent (for 3D) or layers of the dstSubresource (for non-3D)
VUID-VkImageCopy-srcImage-00141
If either of the calling command’s srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of the corresponding subresource must be 0 and 1, respectively
VUID-VkImageCopy-aspectMask-00142
The aspectMask member of srcSubresource must specify aspects present in the calling command’s srcImage
VUID-VkImageCopy-aspectMask-00143
The aspectMask member of dstSubresource must specify aspects present in the calling command’s dstImage
VUID-VkImageCopy-srcOffset-00144
srcOffset.x and (extent.width + srcOffset.x) must both be greater than or equal to 0 and less than or equal to the source image subresource width
VUID-VkImageCopy-srcOffset-00145
srcOffset.y and (extent.height + srcOffset.y) must both be greater than or equal to 0 and less than or equal to the source image subresource height
VUID-VkImageCopy-srcImage-00146
If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset.y must be 0 and extent.height must be 1.
VUID-VkImageCopy-srcOffset-00147
srcOffset.z and (extent.depth + srcOffset.z) must both be greater than or equal to 0 and less than or equal to the source image subresource depth
VUID-VkImageCopy-srcImage-01785
If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset.z must be 0 and extent.depth must be 1.
VUID-VkImageCopy-dstImage-01786
If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset.z must be 0 and extent.depth must be 1.
VUID-VkImageCopy-srcImage-01787
If the calling command’s srcImage is of type VK_IMAGE_TYPE_2D, then srcOffset.z must be 0.
VUID-VkImageCopy-dstImage-01788
If the calling command’s dstImage is of type VK_IMAGE_TYPE_2D, then dstOffset.z must be 0.
VUID-VkImageCopy-srcImage-01790
If both srcImage and dstImage are of type VK_IMAGE_TYPE_2D then extent.depth must be 1.
VUID-VkImageCopy-srcImage-01791
If the calling command’s srcImage is of type VK_IMAGE_TYPE_2D, and the dstImage is of type VK_IMAGE_TYPE_3D, then extent.depth must equal to the layerCount member of srcSubresource.
VUID-VkImageCopy-dstImage-01792
If the calling command’s dstImage is of type VK_IMAGE_TYPE_2D, and the srcImage is of type VK_IMAGE_TYPE_3D, then extent.depth must equal to the layerCount member of dstSubresource.
VUID-VkImageCopy-dstOffset-00150
dstOffset.x and (extent.width + dstOffset.x) must both be greater than or equal to 0 and less than or equal to the destination image subresource width
VUID-VkImageCopy-dstOffset-00151
dstOffset.y and (extent.height + dstOffset.y) must both be greater than or equal to 0 and less than or equal to the destination image subresource height
VUID-VkImageCopy-dstImage-00152
If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset.y must be 0 and extent.height must be 1.
VUID-VkImageCopy-dstOffset-00153
dstOffset.z and (extent.depth + dstOffset.z) must both be greater than or equal to 0 and less than or equal to the destination image subresource depth
VUID-VkImageCopy-srcImage-01727
If the calling command’s srcImage is a compressed image, or a single-plane, “_422” image format, all members of srcOffset must be a multiple of the corresponding dimensions of the compressed texel block
VUID-VkImageCopy-srcImage-01728
If the calling command’s srcImage is a compressed image, or a single-plane, “_422” image format, extent.width must be a multiple of the compressed texel block width or (extent.width + srcOffset.x) must equal the source image subresource width
VUID-VkImageCopy-srcImage-01729
If the calling command’s srcImage is a compressed image, or a single-plane, “_422” image format, extent.height must be a multiple of the compressed texel block height or (extent.height + srcOffset.y) must equal the source image subresource height
VUID-VkImageCopy-srcImage-01730
If the calling command’s srcImage is a compressed image, or a single-plane, “_422” image format, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + srcOffset.z) must equal the source image subresource depth
VUID-VkImageCopy-dstImage-01731
If the calling command’s dstImage is a compressed format image, or a single-plane, “_422” image format, all members of dstOffset must be a multiple of the corresponding dimensions of the compressed texel block
VUID-VkImageCopy-dstImage-01732
If the calling command’s dstImage is a compressed format image, or a single-plane, “_422” image format, extent.width must be a multiple of the compressed texel block width or (extent.width + dstOffset.x) must equal the destination image subresource width
VUID-VkImageCopy-dstImage-01733
If the calling command’s dstImage is a compressed format image, or a single-plane, “_422” image format, extent.height must be a multiple of the compressed texel block height or (extent.height + dstOffset.y) must equal the destination image subresource height
VUID-VkImageCopy-dstImage-01734
If the calling command’s dstImage is a compressed format image, or a single-plane, “_422” image format, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + dstOffset.z) must equal the destination image subresource depth

Valid Usage (Implicit)

VUID-VkImageCopy-srcSubresource-parameter
srcSubresource must be a valid VkImageSubresourceLayers structure
VUID-VkImageCopy-dstSubresource-parameter
dstSubresource must be a valid VkImageSubresourceLayers structure

The VkImageSubresourceLayers structure is defined as:

typedef struct VkImageSubresourceLayers {
    VkImageAspectFlags    aspectMask;
    uint32_t              mipLevel;
    uint32_t              baseArrayLayer;
    uint32_t              layerCount;
} VkImageSubresourceLayers;

aspectMask is a combination of VkImageAspectFlagBits, selecting the color, depth and/or stencil aspects to be copied.
mipLevel is the mipmap level to copy from.
baseArrayLayer and layerCount are the starting layer and number of layers to copy.

Valid Usage

VUID-VkImageSubresourceLayers-aspectMask-00167
If aspectMask contains VK_IMAGE_ASPECT_COLOR_BIT, it must not contain either of VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT
VUID-VkImageSubresourceLayers-aspectMask-00168
aspectMask must not contain VK_IMAGE_ASPECT_METADATA_BIT
VUID-VkImageSubresourceLayers-aspectMask-02247
aspectMask must not include VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT for any index i.
VUID-VkImageSubresourceLayers-layerCount-01700
layerCount must be greater than 0

Valid Usage (Implicit)

VUID-VkImageSubresourceLayers-aspectMask-parameter
aspectMask must be a valid combination of VkImageAspectFlagBits values
VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask
aspectMask must not be 0

19.4. Copying Data Between Buffers and Images

To copy data from a buffer object to an image object, call:

void vkCmdCopyBufferToImage(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    srcBuffer,
    VkImage                                     dstImage,
    VkImageLayout                               dstImageLayout,
    uint32_t                                    regionCount,
    const VkBufferImageCopy*                    pRegions);

commandBuffer is the command buffer into which the command will be recorded.
srcBuffer is the source buffer.
dstImage is the destination image.
dstImageLayout is the layout of the destination image subresources for the copy.
regionCount is the number of regions to copy.
pRegions is a pointer to an array of VkBufferImageCopy structures specifying the regions to copy.

Each region in pRegions is copied from the specified region of the source buffer to the specified region of the destination image.

If the format of dstImage is a multi-planar image format), regions of each plane to be a target of a copy must be specified separately using the pRegions member of the VkBufferImageCopy structure. In this case, the aspectMask of imageSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT. For the purposes of vkCmdCopyBufferToImage, each plane of a multi-planar image is treated as having the format listed in Compatible formats of planes of multi-planar formats for the plane identified by the aspectMask of the corresponding subresource. This applies both to VkFormat and to coordinates used in the copy, which correspond to texels in the plane rather than how these texels map to coordinates in the image as a whole.

Valid Usage

VUID-vkCmdCopyBufferToImage-pRegions-00171
srcBuffer must be large enough to contain all buffer locations that are accessed according to Buffer and Image Addressing, for each element of pRegions
VUID-vkCmdCopyBufferToImage-pRegions-00172
The image region specified by each element of pRegions must be a region that is contained within dstImage if the dstImage’s VkFormat is not a multi-planar format, and must be a region that is contained within the plane being copied to if the dstImage’s VkFormat is a multi-planar format
VUID-vkCmdCopyBufferToImage-pRegions-00173
The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory
VUID-vkCmdCopyBufferToImage-srcBuffer-00174
srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag
VUID-vkCmdCopyBufferToImage-dstImage-01997
The format features of dstImage must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT.
VUID-vkCmdCopyBufferToImage-srcBuffer-00176
If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdCopyBufferToImage-dstImage-00177
dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag
VUID-vkCmdCopyBufferToImage-dstImage-00178
If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdCopyBufferToImage-dstImage-00179
dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT
VUID-vkCmdCopyBufferToImage-dstImageLayout-00180
dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice
VUID-vkCmdCopyBufferToImage-dstImageLayout-01396
dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR
VUID-vkCmdCopyBufferToImage-commandBuffer-01828
If commandBuffer is an unprotected command buffer, then srcBuffer must not be a protected buffer
VUID-vkCmdCopyBufferToImage-commandBuffer-01829
If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image
VUID-vkCmdCopyBufferToImage-commandBuffer-01830
If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image
VUID-vkCmdCopyBufferToImage-imageSubresource-01701
The imageSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created
VUID-vkCmdCopyBufferToImage-imageSubresource-01702
The imageSubresource.baseArrayLayer + imageSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created
VUID-vkCmdCopyBufferToImage-imageOffset-01793
The imageOffset and imageExtent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties
VUID-vkCmdCopyBufferToImage-dstImage-02543
dstImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT

Valid Usage (Implicit)

VUID-vkCmdCopyBufferToImage-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdCopyBufferToImage-srcBuffer-parameter
srcBuffer must be a valid VkBuffer handle
VUID-vkCmdCopyBufferToImage-dstImage-parameter
dstImage must be a valid VkImage handle
VUID-vkCmdCopyBufferToImage-dstImageLayout-parameter
dstImageLayout must be a valid VkImageLayout value
VUID-vkCmdCopyBufferToImage-pRegions-parameter
pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy structures
VUID-vkCmdCopyBufferToImage-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdCopyBufferToImage-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations
VUID-vkCmdCopyBufferToImage-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdCopyBufferToImage-regionCount-arraylength
regionCount must be greater than 0
VUID-vkCmdCopyBufferToImage-commonparent
Each of commandBuffer, dstImage, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Transfer
Graphics
Compute

Transfer

To copy data from an image object to a buffer object, call:

void vkCmdCopyImageToBuffer(
    VkCommandBuffer                             commandBuffer,
    VkImage                                     srcImage,
    VkImageLayout                               srcImageLayout,
    VkBuffer                                    dstBuffer,
    uint32_t                                    regionCount,
    const VkBufferImageCopy*                    pRegions);

commandBuffer is the command buffer into which the command will be recorded.
srcImage is the source image.
srcImageLayout is the layout of the source image subresources for the copy.
dstBuffer is the destination buffer.
regionCount is the number of regions to copy.
pRegions is a pointer to an array of VkBufferImageCopy structures specifying the regions to copy.

Each region in pRegions is copied from the specified region of the source image to the specified region of the destination buffer.

If the VkFormat of srcImage is a multi-planar image format, regions of each plane to be a source of a copy must be specified separately using the pRegions member of the VkBufferImageCopy structure. In this case, the aspectMask of imageSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT. For the purposes of vkCmdCopyBufferToImage, each plane of a multi-planar image is treated as having the format listed in Compatible formats of planes of multi-planar formats for the plane identified by the aspectMask of the corresponding subresource. This applies both to VkFormat and to coordinates used in the copy, which correspond to texels in the plane rather than how these texels map to coordinates in the image as a whole.

Valid Usage

VUID-vkCmdCopyImageToBuffer-pRegions-00182
The image region specified by each element of pRegions must be a region that is contained within srcImage if the srcImage’s VkFormat is not a multi-planar format, and must be a region that is contained within the plane being copied if the srcImage’s VkFormat is a multi-planar format
VUID-vkCmdCopyImageToBuffer-pRegions-00183
dstBuffer must be large enough to contain all buffer locations that are accessed according to Buffer and Image Addressing, for each element of pRegions
VUID-vkCmdCopyImageToBuffer-pRegions-00184
The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory
VUID-vkCmdCopyImageToBuffer-srcImage-01998
The format features of srcImage must contain VK_FORMAT_FEATURE_TRANSFER_SRC_BIT.
VUID-vkCmdCopyImageToBuffer-srcImage-00186
srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag
VUID-vkCmdCopyImageToBuffer-srcImage-00187
If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdCopyImageToBuffer-srcImage-00188
srcImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT
VUID-vkCmdCopyImageToBuffer-srcImageLayout-00189
srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice
VUID-vkCmdCopyImageToBuffer-srcImageLayout-01397
srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
VUID-vkCmdCopyImageToBuffer-dstBuffer-00191
dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag
VUID-vkCmdCopyImageToBuffer-dstBuffer-00192
If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdCopyImageToBuffer-commandBuffer-01831
If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image
VUID-vkCmdCopyImageToBuffer-commandBuffer-01832
If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer
VUID-vkCmdCopyImageToBuffer-commandBuffer-01833
If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer
VUID-vkCmdCopyImageToBuffer-imageSubresource-01703
The imageSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created
VUID-vkCmdCopyImageToBuffer-imageSubresource-01704
The imageSubresource.baseArrayLayer + imageSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created
VUID-vkCmdCopyImageToBuffer-imageOffset-01794
The imageOffset and imageExtent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties
VUID-vkCmdCopyImageToBuffer-srcImage-02544
srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT

Valid Usage (Implicit)

VUID-vkCmdCopyImageToBuffer-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdCopyImageToBuffer-srcImage-parameter
srcImage must be a valid VkImage handle
VUID-vkCmdCopyImageToBuffer-srcImageLayout-parameter
srcImageLayout must be a valid VkImageLayout value
VUID-vkCmdCopyImageToBuffer-dstBuffer-parameter
dstBuffer must be a valid VkBuffer handle
VUID-vkCmdCopyImageToBuffer-pRegions-parameter
pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy structures
VUID-vkCmdCopyImageToBuffer-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdCopyImageToBuffer-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations
VUID-vkCmdCopyImageToBuffer-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdCopyImageToBuffer-regionCount-arraylength
regionCount must be greater than 0
VUID-vkCmdCopyImageToBuffer-commonparent
Each of commandBuffer, dstBuffer, and srcImage must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Transfer
Graphics
Compute

Transfer

For both vkCmdCopyBufferToImage and vkCmdCopyImageToBuffer, each element of pRegions is a structure defined as:

typedef struct VkBufferImageCopy {
    VkDeviceSize                bufferOffset;
    uint32_t                    bufferRowLength;
    uint32_t                    bufferImageHeight;
    VkImageSubresourceLayers    imageSubresource;
    VkOffset3D                  imageOffset;
    VkExtent3D                  imageExtent;
} VkBufferImageCopy;

bufferOffset is the offset in bytes from the start of the buffer object where the image data is copied from or to.
bufferRowLength and bufferImageHeight specify in texels a subregion of a larger two- or three-dimensional image in buffer memory, and control the addressing calculations. If either of these values is zero, that aspect of the buffer memory is considered to be tightly packed according to the imageExtent.
imageSubresource is a VkImageSubresourceLayers used to specify the specific image subresources of the image used for the source or destination image data.
imageOffset selects the initial x, y, z offsets in texels of the sub-region of the source or destination image data.
imageExtent is the size in texels of the image to copy in width, height and depth.

When copying to or from a depth or stencil aspect, the data in buffer memory uses a layout that is a (mostly) tightly packed representation of the depth or stencil data. Specifically:

data copied to or from the stencil aspect of any depth/stencil format is tightly packed with one VK_FORMAT_S8_UINT value per texel.
data copied to or from the depth aspect of a VK_FORMAT_D16_UNORM or VK_FORMAT_D16_UNORM_S8_UINT format is tightly packed with one VK_FORMAT_D16_UNORM value per texel.
data copied to or from the depth aspect of a VK_FORMAT_D32_SFLOAT or VK_FORMAT_D32_SFLOAT_S8_UINT format is tightly packed with one VK_FORMAT_D32_SFLOAT value per texel.
data copied to or from the depth aspect of a VK_FORMAT_X8_D24_UNORM_PACK32 or VK_FORMAT_D24_UNORM_S8_UINT format is packed with one 32-bit word per texel with the D24 value in the LSBs of the word, and undefined values in the eight MSBs.

Note

To copy both the depth and stencil aspects of a depth/stencil format, two entries in pRegions can be used, where one specifies the depth aspect in imageSubresource, and the other specifies the stencil aspect.

Because depth or stencil aspect buffer to image copies may require format conversions on some implementations, they are not supported on queues that do not support graphics.

When copying to a depth aspect, and the VK_EXT_depth_range_unrestricted extension is not enabled, the data in buffer memory must be in the range [0,1], or the resulting values are undefined.

Copies are done layer by layer starting with image layer baseArrayLayer member of imageSubresource. layerCount layers are copied from the source image or to the destination image.

Valid Usage

VUID-VkBufferImageCopy-bufferOffset-01558
If the calling command’s VkImage parameter’s format is not a depth/stencil format or a multi-planar format, then bufferOffset must be a multiple of the format’s texel block size.
VUID-VkBufferImageCopy-bufferOffset-01559
If the calling command’s VkImage parameter’s format is a multi-planar format, then bufferOffset must be a multiple of the element size of the compatible format for the format and the aspectMask of the imageSubresource as defined in Compatible formats of planes of multi-planar formats
VUID-VkBufferImageCopy-bufferOffset-00194
bufferOffset must be a multiple of 4
VUID-VkBufferImageCopy-bufferRowLength-00195
bufferRowLength must be 0, or greater than or equal to the width member of imageExtent
VUID-VkBufferImageCopy-bufferImageHeight-00196
bufferImageHeight must be 0, or greater than or equal to the height member of imageExtent
VUID-VkBufferImageCopy-imageOffset-00197
imageOffset.x and (imageExtent.width + imageOffset.x) must both be greater than or equal to 0 and less than or equal to the image subresource width where this refers to the width of the plane of the image involved in the copy in the case of a multi-planar format
VUID-VkBufferImageCopy-imageOffset-00198
imageOffset.y and (imageExtent.height + imageOffset.y) must both be greater than or equal to 0 and less than or equal to the image subresource height where this refers to the height of the plane of the image involved in the copy in the case of a multi-planar format
VUID-VkBufferImageCopy-srcImage-00199
If the calling command’s srcImage (vkCmdCopyImageToBuffer) or dstImage (vkCmdCopyBufferToImage) is of type VK_IMAGE_TYPE_1D, then imageOffset.y must be 0 and imageExtent.height must be 1.
VUID-VkBufferImageCopy-imageOffset-00200
imageOffset.z and (imageExtent.depth + imageOffset.z) must both be greater than or equal to 0 and less than or equal to the image subresource depth
VUID-VkBufferImageCopy-srcImage-00201
If the calling command’s srcImage (vkCmdCopyImageToBuffer) or dstImage (vkCmdCopyBufferToImage) is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then imageOffset.z must be 0 and imageExtent.depth must be 1
VUID-VkBufferImageCopy-None-01735
If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, bufferRowLength must be a multiple of the compressed texel block width
VUID-VkBufferImageCopy-None-01736
If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, bufferImageHeight must be a multiple of the compressed texel block height
VUID-VkBufferImageCopy-None-01737
If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, all members of imageOffset must be a multiple of the corresponding dimensions of the compressed texel block
VUID-VkBufferImageCopy-None-01738
If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, bufferOffset must be a multiple of the compressed texel block size in bytes
VUID-VkBufferImageCopy-None-01739
If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, imageExtent.width must be a multiple of the compressed texel block width or (imageExtent.width + imageOffset.x) must equal the image subresource width
VUID-VkBufferImageCopy-None-01740
If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, imageExtent.height must be a multiple of the compressed texel block height or (imageExtent.height + imageOffset.y) must equal the image subresource height
VUID-VkBufferImageCopy-None-01741
If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, imageExtent.depth must be a multiple of the compressed texel block depth or (imageExtent.depth + imageOffset.z) must equal the image subresource depth
VUID-VkBufferImageCopy-aspectMask-00211
The aspectMask member of imageSubresource must specify aspects present in the calling command’s VkImage parameter
VUID-VkBufferImageCopy-aspectMask-01560
If the calling command’s VkImage parameter’s format is a multi-planar format, then the aspectMask member of imageSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT (with VK_IMAGE_ASPECT_PLANE_2_BIT valid only for image formats with three planes)
VUID-VkBufferImageCopy-aspectMask-00212
The aspectMask member of imageSubresource must only have a single bit set
VUID-VkBufferImageCopy-baseArrayLayer-00213
If the calling command’s VkImage parameter is of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of imageSubresource must be 0 and 1, respectively

Valid Usage (Implicit)

VUID-VkBufferImageCopy-imageSubresource-parameter
imageSubresource must be a valid VkImageSubresourceLayers structure

19.4.1. Buffer and Image Addressing

Pseudocode for image/buffer addressing of uncompressed formats is:

rowLength = region->bufferRowLength;
if (rowLength == 0)
    rowLength = region->imageExtent.width;

imageHeight = region->bufferImageHeight;
if (imageHeight == 0)
    imageHeight = region->imageExtent.height;

texelBlockSize = <texel block size of the format of the src/dstImage>;

address of (x,y,z) = region->bufferOffset + (((z * imageHeight) + y) * rowLength + x) * texelBlockSize;

where x,y,z range from (0,0,0) to region->imageExtent.{width,height,depth}.

Note that imageOffset does not affect addressing calculations for buffer memory. Instead, bufferOffset can be used to select the starting address in buffer memory.

For block-compressed formats, all parameters are still specified in texels rather than compressed texel blocks, but the addressing math operates on whole compressed texel blocks. Pseudocode for compressed copy addressing is:

rowLength = region->bufferRowLength;
if (rowLength == 0)
    rowLength = region->imageExtent.width;

imageHeight = region->bufferImageHeight;
if (imageHeight == 0)
    imageHeight = region->imageExtent.height;

compressedTexelBlockSizeInBytes = <compressed texel block size taken from the src/dstImage>;
rowLength /= compressedTexelBlockWidth;
imageHeight /= compressedTexelBlockHeight;

address of (x,y,z) = region->bufferOffset + (((z * imageHeight) + y) * rowLength + x) * compressedTexelBlockSizeInBytes;

where x,y,z range from (0,0,0) to region->imageExtent.{width/compressedTexelBlockWidth,height/compressedTexelBlockHeight,depth/compressedTexelBlockDepth}.

Copying to or from block-compressed images is typically done in multiples of the compressed texel block size. For this reason the imageExtent must be a multiple of the compressed texel 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 compressed texel block dimensions:

If imageExtent.width is not a multiple of the compressed texel block width, then (imageExtent.width + imageOffset.x) must equal the image subresource width.
If imageExtent.height is not a multiple of the compressed texel block height, then (imageExtent.height + imageOffset.y) must equal the image subresource height.
If imageExtent.depth is not a multiple of the compressed texel block depth, then (imageExtent.depth + imageOffset.z) must equal the image subresource depth.

This allows the last compressed texel block of the image in each non-multiple dimension to be included as a source or destination of the copy.

19.5. Image Copies with Scaling

To copy regions of a source image into a destination image, potentially performing format conversion, arbitrary scaling, and filtering, call:

void vkCmdBlitImage(
    VkCommandBuffer                             commandBuffer,
    VkImage                                     srcImage,
    VkImageLayout                               srcImageLayout,
    VkImage                                     dstImage,
    VkImageLayout                               dstImageLayout,
    uint32_t                                    regionCount,
    const VkImageBlit*                          pRegions,
    VkFilter                                    filter);

commandBuffer is the command buffer into which the command will be recorded.
srcImage is the source image.
srcImageLayout is the layout of the source image subresources for the blit.
dstImage is the destination image.
dstImageLayout is the layout of the destination image subresources for the blit.
regionCount is the number of regions to blit.
pRegions is a pointer to an array of VkImageBlit structures specifying the regions to blit.
filter is a VkFilter specifying the filter to apply if the blits require scaling.

vkCmdBlitImage must not be used for multisampled source or destination images. Use vkCmdResolveImage for this purpose.

As the sizes of the source and destination extents can differ in any dimension, texels in the source extent are scaled and filtered to the destination extent. Scaling occurs via the following operations:

For each destination texel, the integer coordinate of that texel is converted to an unnormalized texture coordinate, using the effective inverse of the equations described in unnormalized to integer conversion:

u_base = i + ½

v_base = j + ½

w_base = k + ½
These base coordinates are then offset by the first destination offset:

u_offset = u_base - x_dst0

v_offset = v_base - y_dst0

w_offset = w_base - z_dst0

a_offset = a - baseArrayCount_dst
The scale is determined from the source and destination regions, and applied to the offset coordinates:

scale_u = (x_src1 - x_src0) / (x_dst1 - x_dst0)

scale_v = (y_src1 - y_src0) / (y_dst1 - y_dst0)

scale_w = (z_src1 - z_src0) / (z_dst1 - z_dst0)

u_scaled = u_offset * scale_u

v_scaled = v_offset * scale_v

w_scaled = w_offset * scale_w
Finally the source offset is added to the scaled coordinates, to determine the final unnormalized coordinates used to sample from srcImage:

u = u_scaled + x_src0

v = v_scaled + y_src0

w = w_scaled + z_src0

q = mipLevel

a = a_offset + baseArrayCount_src

These coordinates are used to sample from the source image, as described in Image Operations chapter, with the filter mode equal to that of filter, a mipmap mode of VK_SAMPLER_MIPMAP_MODE_NEAREST and an address mode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE. Implementations must clamp at the edge of the source image, and may additionally clamp to the edge of the source region.

Note

Due to allowable rounding errors in the generation of the source texture coordinates, it is not always possible to guarantee exactly which source texels will be sampled for a given blit. As rounding errors are implementation dependent, the exact results of a blitting operation are also implementation dependent.

Blits are done layer by layer starting with the baseArrayLayer member of srcSubresource for the source and dstSubresource for the destination. layerCount layers are blitted to the destination image.

3D textures are blitted slice by slice. Slices in the source region bounded by srcOffsets[0].z and srcOffsets[1].z are copied to slices in the destination region bounded by dstOffsets[0].z and dstOffsets[1].z. For each destination slice, a source z coordinate is linearly interpolated between srcOffsets[0].z and srcOffsets[1].z. If the filter parameter is VK_FILTER_LINEAR then the value sampled from the source image is taken by doing linear filtering using the interpolated z coordinate. If filter parameter is VK_FILTER_NEAREST then the value sampled from the source image is taken from the single nearest slice, with an implementation-dependent arithmetic rounding mode.

The following filtering and conversion rules apply:

Integer formats can only be converted to other integer formats with the same signedness.
No format conversion is supported between depth/stencil images. The formats must match.
Format conversions on unorm, snorm, unscaled and packed float formats of the copied aspect of the image are performed by first converting the pixels to float values.
For sRGB source formats, nonlinear RGB values are converted to linear representation prior to filtering.
After filtering, the float values are first clamped and then cast to the destination image format. In case of sRGB destination format, linear RGB values are converted to nonlinear representation before writing the pixel to the image.

Signed and unsigned integers are converted by first clamping to the representable range of the destination format, then casting the value.

Valid Usage

VUID-vkCmdBlitImage-pRegions-00215
The source region specified by each element of pRegions must be a region that is contained within srcImage
VUID-vkCmdBlitImage-pRegions-00216
The destination region specified by each element of pRegions must be a region that is contained within dstImage
VUID-vkCmdBlitImage-pRegions-00217
The union of all destination regions, specified by the elements of pRegions, must not overlap in memory with any texel that may be sampled during the blit operation
VUID-vkCmdBlitImage-srcImage-01999
The format features of srcImage must contain VK_FORMAT_FEATURE_BLIT_SRC_BIT.
VUID-vkCmdBlitImage-srcImage-01561
srcImage must not use a format listed in Formats requiring sampler Y′C_BC_R conversion for VK_IMAGE_ASPECT_COLOR_BIT image views
VUID-vkCmdBlitImage-srcImage-00219
srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag
VUID-vkCmdBlitImage-srcImage-00220
If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdBlitImage-srcImageLayout-00221
srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice
VUID-vkCmdBlitImage-srcImageLayout-01398
srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
VUID-vkCmdBlitImage-dstImage-02000
The format features of dstImage must contain VK_FORMAT_FEATURE_BLIT_DST_BIT.
VUID-vkCmdBlitImage-dstImage-01562
dstImage must not use a format listed in Formats requiring sampler Y′C_BC_R conversion for VK_IMAGE_ASPECT_COLOR_BIT image views
VUID-vkCmdBlitImage-dstImage-00224
dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag
VUID-vkCmdBlitImage-dstImage-00225
If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdBlitImage-dstImageLayout-00226
dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice
VUID-vkCmdBlitImage-dstImageLayout-01399
dstImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
VUID-vkCmdBlitImage-srcImage-00228
The sample count of srcImage and dstImage must both be equal to VK_SAMPLE_COUNT_1_BIT
VUID-vkCmdBlitImage-srcImage-00229
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
VUID-vkCmdBlitImage-srcImage-00230
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
VUID-vkCmdBlitImage-srcImage-00231
If either of srcImage or dstImage was created with a depth/stencil format, the other must have exactly the same format
VUID-vkCmdBlitImage-srcImage-00232
If srcImage was created with a depth/stencil format, filter must be VK_FILTER_NEAREST
VUID-vkCmdBlitImage-srcImage-00233
srcImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT
VUID-vkCmdBlitImage-dstImage-00234
dstImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT
VUID-vkCmdBlitImage-filter-02001
If filter is VK_FILTER_LINEAR, then the format features of srcImage must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT.
VUID-vkCmdBlitImage-filter-02002
If filter is VK_FILTER_CUBIC_EXT, then the format features of srcImage must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT.
VUID-vkCmdBlitImage-filter-00237
If filter is VK_FILTER_CUBIC_EXT, srcImage must have a VkImageType of VK_IMAGE_TYPE_2D
VUID-vkCmdBlitImage-commandBuffer-01834
If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image
VUID-vkCmdBlitImage-commandBuffer-01835
If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image
VUID-vkCmdBlitImage-commandBuffer-01836
If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image
VUID-vkCmdBlitImage-srcSubresource-01705
The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created
VUID-vkCmdBlitImage-dstSubresource-01706
The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created
VUID-vkCmdBlitImage-srcSubresource-01707
The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created
VUID-vkCmdBlitImage-dstSubresource-01708
The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created
VUID-vkCmdBlitImage-dstImage-02545
dstImage and srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT

Valid Usage (Implicit)

VUID-vkCmdBlitImage-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdBlitImage-srcImage-parameter
srcImage must be a valid VkImage handle
VUID-vkCmdBlitImage-srcImageLayout-parameter
srcImageLayout must be a valid VkImageLayout value
VUID-vkCmdBlitImage-dstImage-parameter
dstImage must be a valid VkImage handle
VUID-vkCmdBlitImage-dstImageLayout-parameter
dstImageLayout must be a valid VkImageLayout value
VUID-vkCmdBlitImage-pRegions-parameter
pRegions must be a valid pointer to an array of regionCount valid VkImageBlit structures
VUID-vkCmdBlitImage-filter-parameter
filter must be a valid VkFilter value
VUID-vkCmdBlitImage-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdBlitImage-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdBlitImage-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdBlitImage-regionCount-arraylength
regionCount must be greater than 0
VUID-vkCmdBlitImage-commonparent
Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Graphics

Transfer

The VkImageBlit structure is defined as:

typedef struct VkImageBlit {
    VkImageSubresourceLayers    srcSubresource;
    VkOffset3D                  srcOffsets[2];
    VkImageSubresourceLayers    dstSubresource;
    VkOffset3D                  dstOffsets[2];
} VkImageBlit;

srcSubresource is the subresource to blit from.
srcOffsets is a pointer to an array of two VkOffset3D structures specifying the bounds of the source region within srcSubresource.
dstSubresource is the subresource to blit into.
dstOffsets is a pointer to an array of two VkOffset3D structures specifying the bounds of the destination region within dstSubresource.

For each element of the pRegions array, a blit operation is performed the specified source and destination regions.

Valid Usage

VUID-VkImageBlit-aspectMask-00238
The aspectMask member of srcSubresource and dstSubresource must match
VUID-VkImageBlit-layerCount-00239
The layerCount member of srcSubresource and dstSubresource must match
VUID-VkImageBlit-srcImage-00240
If either of the calling command’s srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of both srcSubresource and dstSubresource must be 0 and 1, respectively
VUID-VkImageBlit-aspectMask-00241
The aspectMask member of srcSubresource must specify aspects present in the calling command’s srcImage
VUID-VkImageBlit-aspectMask-00242
The aspectMask member of dstSubresource must specify aspects present in the calling command’s dstImage
VUID-VkImageBlit-srcOffset-00243
srcOffset[0].x and srcOffset[1].x must both be greater than or equal to 0 and less than or equal to the source image subresource width
VUID-VkImageBlit-srcOffset-00244
srcOffset[0].y and srcOffset[1].y must both be greater than or equal to 0 and less than or equal to the source image subresource height
VUID-VkImageBlit-srcImage-00245
If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset[0].y must be 0 and srcOffset[1].y must be 1.
VUID-VkImageBlit-srcOffset-00246
srcOffset[0].z and srcOffset[1].z must both be greater than or equal to 0 and less than or equal to the source image subresource depth
VUID-VkImageBlit-srcImage-00247
If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then srcOffset[0].z must be 0 and srcOffset[1].z must be 1.
VUID-VkImageBlit-dstOffset-00248
dstOffset[0].x and dstOffset[1].x must both be greater than or equal to 0 and less than or equal to the destination image subresource width
VUID-VkImageBlit-dstOffset-00249
dstOffset[0].y and dstOffset[1].y must both be greater than or equal to 0 and less than or equal to the destination image subresource height
VUID-VkImageBlit-dstImage-00250
If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset[0].y must be 0 and dstOffset[1].y must be 1.
VUID-VkImageBlit-dstOffset-00251
dstOffset[0].z and dstOffset[1].z must both be greater than or equal to 0 and less than or equal to the destination image subresource depth
VUID-VkImageBlit-dstImage-00252
If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then dstOffset[0].z must be 0 and dstOffset[1].z must be 1.

Valid Usage (Implicit)

VUID-VkImageBlit-srcSubresource-parameter
srcSubresource must be a valid VkImageSubresourceLayers structure
VUID-VkImageBlit-dstSubresource-parameter
dstSubresource must be a valid VkImageSubresourceLayers structure

19.6. Resolving Multisample Images

To resolve a multisample image to a non-multisample image, call:

void vkCmdResolveImage(
    VkCommandBuffer                             commandBuffer,
    VkImage                                     srcImage,
    VkImageLayout                               srcImageLayout,
    VkImage                                     dstImage,
    VkImageLayout                               dstImageLayout,
    uint32_t                                    regionCount,
    const VkImageResolve*                       pRegions);

commandBuffer is the command buffer into which the command will be recorded.
srcImage is the source image.
srcImageLayout is the layout of the source image subresources for the resolve.
dstImage is the destination image.
dstImageLayout is the layout of the destination image subresources for the resolve.
regionCount is the number of regions to resolve.
pRegions is a pointer to an array of VkImageResolve structures specifying the regions to resolve.

During the resolve the samples corresponding to each pixel location in the source are converted to a single sample before being written to the destination. If the source formats are floating-point or normalized types, the sample values for each pixel are resolved in an implementation-dependent manner. If the source formats are integer types, a single sample’s value is selected for each pixel.

srcOffset and dstOffset select the initial x, y, and z offsets in texels of the sub-regions of the source and destination image data. extent is the size in texels of the source image to resolve in width, height and depth.

Resolves are done layer by layer starting with baseArrayLayer member of srcSubresource for the source and dstSubresource for the destination. layerCount layers are resolved to the destination image.

Valid Usage

VUID-vkCmdResolveImage-pRegions-00253
The source region specified by each element of pRegions must be a region that is contained within srcImage
VUID-vkCmdResolveImage-pRegions-00254
The destination region specified by each element of pRegions must be a region that is contained within dstImage
VUID-vkCmdResolveImage-pRegions-00255
The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory
VUID-vkCmdResolveImage-srcImage-00256
If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdResolveImage-srcImage-00257
srcImage must have a sample count equal to any valid sample count value other than VK_SAMPLE_COUNT_1_BIT
VUID-vkCmdResolveImage-dstImage-00258
If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdResolveImage-dstImage-00259
dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT
VUID-vkCmdResolveImage-srcImageLayout-00260
srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice
VUID-vkCmdResolveImage-srcImageLayout-01400
srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
VUID-vkCmdResolveImage-dstImageLayout-00262
dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice
VUID-vkCmdResolveImage-dstImageLayout-01401
dstImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
VUID-vkCmdResolveImage-dstImage-02003
The format features of dstImage must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT.
VUID-vkCmdResolveImage-srcImage-01386
srcImage and dstImage must have been created with the same image format
VUID-vkCmdResolveImage-commandBuffer-01837
If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image
VUID-vkCmdResolveImage-commandBuffer-01838
If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image
VUID-vkCmdResolveImage-commandBuffer-01839
If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image
VUID-vkCmdResolveImage-srcSubresource-01709
The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created
VUID-vkCmdResolveImage-dstSubresource-01710
The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created
VUID-vkCmdResolveImage-srcSubresource-01711
The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created
VUID-vkCmdResolveImage-dstSubresource-01712
The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created
VUID-vkCmdResolveImage-dstImage-02546
dstImage and srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT

Valid Usage (Implicit)

VUID-vkCmdResolveImage-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdResolveImage-srcImage-parameter
srcImage must be a valid VkImage handle
VUID-vkCmdResolveImage-srcImageLayout-parameter
srcImageLayout must be a valid VkImageLayout value
VUID-vkCmdResolveImage-dstImage-parameter
dstImage must be a valid VkImage handle
VUID-vkCmdResolveImage-dstImageLayout-parameter
dstImageLayout must be a valid VkImageLayout value
VUID-vkCmdResolveImage-pRegions-parameter
pRegions must be a valid pointer to an array of regionCount valid VkImageResolve structures
VUID-vkCmdResolveImage-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdResolveImage-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdResolveImage-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdResolveImage-regionCount-arraylength
regionCount must be greater than 0
VUID-vkCmdResolveImage-commonparent
Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Graphics

Transfer

The VkImageResolve structure is defined as:

typedef struct VkImageResolve {
    VkImageSubresourceLayers    srcSubresource;
    VkOffset3D                  srcOffset;
    VkImageSubresourceLayers    dstSubresource;
    VkOffset3D                  dstOffset;
    VkExtent3D                  extent;
} VkImageResolve;

srcSubresource and dstSubresource are VkImageSubresourceLayers structures specifying the image subresources of the images used for the source and destination image data, respectively. Resolve of depth/stencil images is not supported.
srcOffset and dstOffset select the initial x, y, and z offsets in texels of the sub-regions of the source and destination image data.
extent is the size in texels of the source image to resolve in width, height and depth.

Valid Usage

VUID-VkImageResolve-aspectMask-00266
The aspectMask member of srcSubresource and dstSubresource must only contain VK_IMAGE_ASPECT_COLOR_BIT
VUID-VkImageResolve-layerCount-00267
The layerCount member of srcSubresource and dstSubresource must match
VUID-VkImageResolve-srcImage-00268
If either of the calling command’s srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of both srcSubresource and dstSubresource must be 0 and 1, respectively
VUID-VkImageResolve-srcOffset-00269
srcOffset.x and (extent.width + srcOffset.x) must both be greater than or equal to 0 and less than or equal to the source image subresource width
VUID-VkImageResolve-srcOffset-00270
srcOffset.y and (extent.height + srcOffset.y) must both be greater than or equal to 0 and less than or equal to the source image subresource height
VUID-VkImageResolve-srcImage-00271
If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset.y must be 0 and extent.height must be 1.
VUID-VkImageResolve-srcOffset-00272
srcOffset.z and (extent.depth + srcOffset.z) must both be greater than or equal to 0 and less than or equal to the source image subresource depth
VUID-VkImageResolve-srcImage-00273
If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then srcOffset.z must be 0 and extent.depth must be 1.
VUID-VkImageResolve-dstOffset-00274
dstOffset.x and (extent.width + dstOffset.x) must both be greater than or equal to 0 and less than or equal to the destination image subresource width
VUID-VkImageResolve-dstOffset-00275
dstOffset.y and (extent.height + dstOffset.y) must both be greater than or equal to 0 and less than or equal to the destination image subresource height
VUID-VkImageResolve-dstImage-00276
If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset.y must be 0 and extent.height must be 1.
VUID-VkImageResolve-dstOffset-00277
dstOffset.z and (extent.depth + dstOffset.z) must both be greater than or equal to 0 and less than or equal to the destination image subresource depth
VUID-VkImageResolve-dstImage-00278
If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then dstOffset.z must be 0 and extent.depth must be 1.

Valid Usage (Implicit)

VUID-VkImageResolve-srcSubresource-parameter
srcSubresource must be a valid VkImageSubresourceLayers structure
VUID-VkImageResolve-dstSubresource-parameter
dstSubresource must be a valid VkImageSubresourceLayers structure

19.7. Buffer Markers

To write a 32-bit marker value into a buffer as a pipelined operation, call:

void vkCmdWriteBufferMarkerAMD(
    VkCommandBuffer                             commandBuffer,
    VkPipelineStageFlagBits                     pipelineStage,
    VkBuffer                                    dstBuffer,
    VkDeviceSize                                dstOffset,
    uint32_t                                    marker);

commandBuffer is the command buffer into which the command will be recorded.
pipelineStage is one of the VkPipelineStageFlagBits values, specifying the pipeline stage whose completion triggers the marker write.
dstBuffer is the buffer where the marker will be written to.
dstOffset is the byte offset into the buffer where the marker will be written to.
marker is the 32-bit value of the marker.

The command will write the 32-bit marker value into the buffer only after all preceding commands have finished executing up to at least the specified pipeline stage. This includes the completion of other preceding vkCmdWriteBufferMarkerAMD commands so long as their specified pipeline stages occur either at the same time or earlier than this command’s specified pipelineStage.

While consecutive buffer marker writes with the same pipelineStage parameter are implicitly complete in submission order, memory and execution dependencies between buffer marker writes and other operations must still be explicitly ordered using synchronization commands. The access scope for buffer marker writes falls under the VK_ACCESS_TRANSFER_WRITE_BIT, and the pipeline stages for identifying the synchronization scope must include both pipelineStage and VK_PIPELINE_STAGE_TRANSFER_BIT.

Note

Similar to vkCmdWriteTimestamp, if an implementation is unable to write a marker at any specific pipeline stage, it may instead do so at any logically later stage.

Note

Implementations may only support a limited number of pipelined marker write operations in flight at a given time, thus excessive number of marker write operations may degrade command execution performance.

Valid Usage

VUID-vkCmdWriteBufferMarkerAMD-dstOffset-01798
dstOffset must be less than or equal to the size of dstBuffer minus 4.
VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-01799
dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag
VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-01800
If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdWriteBufferMarkerAMD-dstOffset-01801
dstOffset must be a multiple of 4

Valid Usage (Implicit)

VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-parameter
pipelineStage must be a valid VkPipelineStageFlagBits value
VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-parameter
dstBuffer must be a valid VkBuffer handle
VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations
VUID-vkCmdWriteBufferMarkerAMD-commonparent
Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Transfer
Graphics
Compute

Transfer

20. Drawing Commands

Drawing commands (commands with Draw in the name) provoke work in a graphics pipeline. Drawing commands are recorded into a command buffer and when executed by a queue, will produce work which executes according to the bound graphics pipeline. A graphics pipeline must be bound to a command buffer before any drawing commands are recorded in that command buffer.

Drawing can be achieved in two modes:

Programmable Mesh Shading, the mesh shader assembles primitives, or
Programmable Primitive Shading, the input primitives are assembled

as follows.

Each draw is made up of zero or more vertices and zero or more instances, which are processed by the device and result in the assembly of primitives. Primitives are assembled according to the pInputAssemblyState member of the VkGraphicsPipelineCreateInfo structure, which is of type VkPipelineInputAssemblyStateCreateInfo:

typedef struct VkPipelineInputAssemblyStateCreateInfo {
    VkStructureType                            sType;
    const void*                                pNext;
    VkPipelineInputAssemblyStateCreateFlags    flags;
    VkPrimitiveTopology                        topology;
    VkBool32                                   primitiveRestartEnable;
} VkPipelineInputAssemblyStateCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
topology is a VkPrimitiveTopology defining the primitive topology, as described below.
primitiveRestartEnable controls whether a special vertex index value is treated as restarting the assembly of primitives. This enable only applies to indexed draws (vkCmdDrawIndexed and vkCmdDrawIndexedIndirect), and the special index value is either 0xFFFFFFFF when the indexType parameter of vkCmdBindIndexBuffer is equal to VK_INDEX_TYPE_UINT32, 0xFF when indexType is equal to VK_INDEX_TYPE_UINT8_EXT, or 0xFFFF when indexType is equal to VK_INDEX_TYPE_UINT16. Primitive restart is not allowed for “list” topologies.

Restarting the assembly of primitives discards the most recent index values if those elements formed an incomplete primitive, and restarts the primitive assembly using the subsequent indices, but only assembling the immediately following element through the end of the originally specified elements. The primitive restart index value comparison is performed before adding the vertexOffset value to the index value.

Valid Usage

VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00428
If topology is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY or VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, primitiveRestartEnable must be VK_FALSE
VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00429
If the geometry shaders feature is not enabled, topology must not be any of VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY
VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00430
If the tessellation shaders feature is not enabled, topology must not be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST

Valid Usage (Implicit)

VUID-VkPipelineInputAssemblyStateCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO
VUID-VkPipelineInputAssemblyStateCreateInfo-pNext-pNext
pNext must be NULL
VUID-VkPipelineInputAssemblyStateCreateInfo-flags-zerobitmask
flags must be 0
VUID-VkPipelineInputAssemblyStateCreateInfo-topology-parameter
topology must be a valid VkPrimitiveTopology value

typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;

VkPipelineInputAssemblyStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

20.1. Primitive Topologies

Primitive topology determines how consecutive vertices are organized into primitives, and determines the type of primitive that is used at the beginning of the graphics pipeline. The effective topology for later stages of the pipeline is altered by tessellation or geometry shading (if either is in use) and depends on the execution modes of those shaders. In the case of mesh shading the only effective topology is defined by the execution mode of the mesh shader.

The primitive topologies defined by VkPrimitiveTopology are:

typedef enum VkPrimitiveTopology {
    VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
    VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
    VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
    VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
    VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
} VkPrimitiveTopology;

VK_PRIMITIVE_TOPOLOGY_POINT_LIST specifies a series of separate point primitives.
VK_PRIMITIVE_TOPOLOGY_LINE_LIST specifies a series of separate line primitives.
VK_PRIMITIVE_TOPOLOGY_LINE_STRIP specifies a series of connected line primitives with consecutive lines sharing a vertex.
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST specifies a series of separate triangle primitives.
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP specifies a series of connected triangle primitives with consecutive triangles sharing an edge.
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN specifies a series of connected triangle primitives with all triangles sharing a common vertex.
VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY specifies a series of separate line primitives with adjacency.
VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY specifies a series of connected line primitives with adjacency, with consecutive primitives sharing three vertices.
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY specifies a series of separate triangle primitives with adjacency.
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY specifies connected triangle primitives with adjacency, with consecutive triangles sharing an edge.
VK_PRIMITIVE_TOPOLOGY_PATCH_LIST specifies separate patch primitives.

Each primitive topology, and its construction from a list of vertices, is described in detail below with a supporting diagram, according to the following key:

Vertex

A point in 3-dimensional space. Positions chosen within the diagrams are arbitrary and for illustration only.

Vertex Number

Sequence position of a vertex within the provided vertex data.

Provoking Vertex

Provoking vertex within the main primitive. The arrow points along an edge of the relevant primitive, following winding order. Used in flat shading.

Primitive Edge

An edge connecting the points of a main primitive.

Adjacency Edge

Points connected by these lines do not contribute to a main primitive, and are only accessible in a geometry shader.

Winding Order

The relative order in which vertices are defined within a primitive, used in the facing determination. This ordering has no specific start or end point.

The diagrams are supported with mathematical definitions where the vertices (v) and primitives (p) are numbered starting from 0; v₀ is the first vertex in the provided data and p₀ is the first primitive in the set of primitives defined by the vertices and topology.

20.1.1. Point Lists

When the topology is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, each consecutive vertex defines a single point primitive, according to the equation:

: p_i = {v_i}

As there is only one vertex, that vertex is the provoking vertex. The number of primitives generated is equal to vertexCount.

20.1.2. Line Lists

When the topology is VK_PRIMITIVE_TOPOLOGY_LINE_LIST, each consecutive pair of vertices defines a single line primitive, according to the equation:

: p_i = {v_2i, v_2i+1}

The provoking vertex for p_i is v_2i. The number of primitives generated is equal to ⌊vertexCount/2⌋.

20.1.3. Line Strips

When the topology is VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, one line primitive is defined by each vertex and the following vertex, according to the equation:

: p_i = {v_i, v_i+1}

The provoking vertex for p_i is v_i. The number of primitives generated is equal to max(0,vertexCount-1).

20.1.4. Triangle Lists

When the topology is VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, each consecutive set of three vertices defines a single triangle primitive, according to the equation:

: p_i = {v_3i, v_3i+1, v_3i+2}

The provoking vertex for p_i is v_3i. The number of primitives generated is equal to ⌊vertexCount/3⌋.

20.1.5. Triangle Strips

When the topology is VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, one triangle primitive is defined by each vertex and the two vertices that follow it, according to the equation:

: p_i = {v_i, v_i+(1+i%2), v_i+(2-i%2)}

The provoking vertex for p_i is v_i. The number of primitives generated is equal to max(0,vertexCount-2).

Note

The ordering of the vertices in each successive triangle is reversed, so that the winding order is consistent throughout the strip.

20.1.6. Triangle Fans

When the topology is VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, triangle primitives are defined around a shared common vertex, according to the equation:

: p_i = {v_i+1, v_i+2, v₀}

The provoking vertex for p_i is v_i+1. The number of primitives generated is equal to max(0,vertexCount-2).

20.1.7. Line Lists With Adjacency

When the topology is VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, each consecutive set of four vertices defines a single line primitive with adjacency, according to the equation:

: p_i = {v_4i, v_4i+1, v_4i+2,v_4i+3}

A line primitive is described by the second and third vertices of the total primitive, with the remaining two vertices only accessible in a geometry shader.

The provoking vertex for p_i is v_4i+1. The number of primitives generated is equal to ⌊vertexCount/4⌋.

20.1.8. Line Strips With Adjacency

When the topology is VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, one line primitive with adjacency is defined by each vertex and the following vertex, according to the equation:

: p_i = {v_i, v_i+1, v_i+2, v_i+3}

A line primitive is described by the second and third vertices of the total primitive, with the remaining two vertices only accessible in a geometry shader.

The provoking vertex for p_i is v_i+1. The number of primitives generated is equal to max(0,vertexCount-3).

20.1.9. Triangle Lists With Adjacency

When the topology is VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, each consecutive set of six vertices defines a single triangle primitive with adjacency, according to the equations:

: p_i = {v_6i, v_6i+1, v_6i+2, v_6i+3, v_6i+4, v_6i+5}

A triangle primitive is described by the first, third, and fifth vertices of the total primitive, with the remaining three vertices only accessible in a geometry shader.

The provoking vertex for p_i is v_6i. The number of primitives generated is equal to ⌊vertexCount/6⌋.

20.1.10. Triangle Strips With Adjacency

When the topology is VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, one triangle primitive with adjacency is defined by each vertex and the following 5 vertices.

The number of primitives generated, n, is equal to ⌊max(0, vertexCount - 4)/2⌋.

If n=1, the primitive is defined as:

: p = {v₀, v₁, v₂, v₅, v₄, v₃}

If n>1, the total primitive consists of different vertices according to where it is in the strip:

: p_i = {v_2i, v_2i+1, v_2i+2, v_2i+6, v_2i+4, v_2i+3} when i=0
: p_i = {v_2i, v_2i+3, v_2i+4, v_2i+6, v_2i+2, v_2i-2} when i>0, i<n-1, and i%2=1
: p_i = {v_2i, v_2i-2, v_2i+2, v_2i+6, v_2i+4, v_2i+3} when i>0, i<n-1, and i%2=0
: p_i = {v_2i, v_2i+3, v_2i+4, v_2i+5, v_2i+2, v_2i-2} when i=n-1 and i%2=1
: p_i = {v_2i, v_2i-2, v_2i+2, v_2i+5, v_2i+4, v_2i+3} when i=n-1 and i%2=0

A triangle primitive is described by the first, third, and fifth vertices of the total primitive in all cases, with the remaining three vertices only accessible in a geometry shader.

Note

The ordering of the vertices in each successive triangle is altered so that the winding order is consistent throughout the strip.

The provoking vertex for p_i is always v_2i.

20.1.11. Patch Lists

When the topology is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, each consecutive set of m vertices defines a single patch primitive, according to the equation:

: p_i = {v_mi, v_mi+1, …, v_mi+(m-2), v_mi+(m-1)}

where m is equal to VkPipelineTessellationStateCreateInfo::patchControlPoints.

Patch lists are never passed to vertex post-processing, and as such no provoking vertex is defined for patch primitives. The number of primitives generated is equal to ⌊vertexCount/m⌋.

The vertices comprising a patch have no implied geometry, and are used as inputs to tessellation shaders and the fixed-function tessellator to generate new point, line, or triangle primitives.

20.2. Primitive Order

Primitives generated by drawing commands progress through the stages of the graphics pipeline in primitive order. Primitive order is initially determined in the following way:

Submission order determines the initial ordering
For indirect draw commands, the order in which accessed instances of the VkDrawIndirectCommand are stored in buffer, from lower indirect buffer addresses to higher addresses.
If a draw command includes multiple instances, the order in which instances are executed, from lower numbered instances to higher.
The order in which primitives are specified by a draw command:
- For non-indexed draws, from vertices with a lower numbered vertexIndex to a higher numbered vertexIndex.
- For indexed draws, vertices sourced from a lower index buffer addresses to higher addresses.
- For draws using mesh shaders, the order is provided by mesh shading.

Within this order implementations further sort primitives:

If tessellation shading is active, by an implementation-dependent order of new primitives generated by tessellation.
If geometry shading is active, by the order new primitives are generated by geometry shading.
If the polygon mode is not VK_POLYGON_MODE_FILL, or VK_POLYGON_MODE_FILL_RECTANGLE_NV, by an implementation-dependent ordering of the new primitives generated within the original primitive.

Primitive order is later used to define rasterization order, which determines the order in which fragments output results to a framebuffer.

20.3. Programmable Primitive Shading

Once primitives are assembled, they proceed to the vertex shading stage of the pipeline. If the draw includes multiple instances, then the set of primitives is sent to the vertex shading stage multiple times, once for each instance.

It is implementation-dependent whether vertex shading occurs on vertices that are discarded as part of incomplete primitives, but if it does occur then it operates as if they were vertices in complete primitives and such invocations can have side effects.

Vertex shading receives two per-vertex inputs from the primitive assembly stage - the vertexIndex and the instanceIndex. How these values are generated is defined below, with each command.

Drawing commands fall roughly into two categories:

Non-indexed drawing commands present a sequential vertexIndex to the vertex shader. The sequential index is generated automatically by the device (see Fixed-Function Vertex Processing for details on both specifying the vertex attributes indexed by vertexIndex, as well as binding vertex buffers containing those attributes to a command buffer). These commands are:
Indexed drawing commands read index values from an index buffer and use this to compute the vertexIndex value for the vertex shader. These commands are:

To bind an index buffer to a command buffer, call:

void vkCmdBindIndexBuffer(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    VkIndexType                                 indexType);

commandBuffer is the command buffer into which the command is recorded.
buffer is the buffer being bound.
offset is the starting offset in bytes within buffer used in index buffer address calculations.
indexType is a VkIndexType value specifying whether indices are treated as 16 bits or 32 bits.

Valid Usage

VUID-vkCmdBindIndexBuffer-offset-00431
offset must be less than the size of buffer
VUID-vkCmdBindIndexBuffer-offset-00432
The sum of offset and the address of the range of VkDeviceMemory object that is backing buffer, must be a multiple of the type indicated by indexType
VUID-vkCmdBindIndexBuffer-buffer-00433
buffer must have been created with the VK_BUFFER_USAGE_INDEX_BUFFER_BIT flag
VUID-vkCmdBindIndexBuffer-buffer-00434
If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdBindIndexBuffer-indexType-02507
indexType must not be VK_INDEX_TYPE_NONE_NV.
VUID-vkCmdBindIndexBuffer-indexType-02765
If indexType is VK_INDEX_TYPE_UINT8_EXT, the indexTypeUint8 feature must be enabled

Valid Usage (Implicit)

VUID-vkCmdBindIndexBuffer-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdBindIndexBuffer-buffer-parameter
buffer must be a valid VkBuffer handle
VUID-vkCmdBindIndexBuffer-indexType-parameter
indexType must be a valid VkIndexType value
VUID-vkCmdBindIndexBuffer-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdBindIndexBuffer-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdBindIndexBuffer-commonparent
Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

Possible values of vkCmdBindIndexBuffer::indexType, specifying the size of indices, are:

typedef enum VkIndexType {
    VK_INDEX_TYPE_UINT16 = 0,
    VK_INDEX_TYPE_UINT32 = 1,
    VK_INDEX_TYPE_NONE_NV = 1000165000,
    VK_INDEX_TYPE_UINT8_EXT = 1000265000,
    VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkIndexType;

VK_INDEX_TYPE_UINT16 specifies that indices are 16-bit unsigned integer values.
VK_INDEX_TYPE_UINT32 specifies that indices are 32-bit unsigned integer values.
VK_INDEX_TYPE_NONE_NV specifies that no indices are provided.
VK_INDEX_TYPE_UINT8_EXT specifies that indices are 8-bit unsigned integer values.

The parameters for each drawing command are specified directly in the command or read from buffer memory, depending on the command. Drawing commands that source their parameters from buffer memory are known as indirect drawing commands.

All drawing commands interact with the Robust Buffer Access feature.

To record a non-indexed draw, call:

void vkCmdDraw(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    vertexCount,
    uint32_t                                    instanceCount,
    uint32_t                                    firstVertex,
    uint32_t                                    firstInstance);

commandBuffer is the command buffer into which the command is recorded.
vertexCount is the number of vertices to draw.
instanceCount is the number of instances to draw.
firstVertex is the index of the first vertex to draw.
firstInstance is the instance ID of the first instance to 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 bound graphics pipeline.

Valid Usage

VUID-vkCmdDraw-None-02690
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
VUID-vkCmdDraw-None-02691
If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
VUID-vkCmdDraw-None-02692
If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT
VUID-vkCmdDraw-filterCubic-02694
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDraw-filterCubicMinmax-02695
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDraw-flags-02696
Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.
VUID-vkCmdDraw-None-02697
For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDraw-None-02698
For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDraw-None-02699
Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command
VUID-vkCmdDraw-None-02700
A valid pipeline must be bound to the pipeline bind point used by this command
VUID-vkCmdDraw-commandBuffer-02701
If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic
VUID-vkCmdDraw-None-02859
There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound
VUID-vkCmdDraw-None-02702
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
VUID-vkCmdDraw-None-02703
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDraw-None-02704
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDraw-None-02705
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDraw-None-02706
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDraw-commandBuffer-02707
If commandBuffer is an unprotected command buffer, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource
VUID-vkCmdDraw-renderPass-02684
The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDraw-subpass-02685
The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDraw-None-02686
Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
VUID-vkCmdDraw-None-02687
Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.
VUID-vkCmdDraw-maxMultiviewInstanceIndex-02688
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
VUID-vkCmdDraw-sampleLocationsEnable-02689
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set
VUID-vkCmdDraw-commandBuffer-02712
If commandBuffer is a protected command buffer, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource
VUID-vkCmdDraw-commandBuffer-02713
If commandBuffer is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the VkPipeline object bound to the pipeline bind point must not write to any resource
VUID-vkCmdDraw-None-02720
All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound
VUID-vkCmdDraw-None-02721
For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description

Valid Usage (Implicit)

VUID-vkCmdDraw-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdDraw-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdDraw-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdDraw-renderpass
This command must only be called inside of a render pass instance

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Inside

Graphics

To record an indexed draw, call:

void vkCmdDrawIndexed(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    indexCount,
    uint32_t                                    instanceCount,
    uint32_t                                    firstIndex,
    int32_t                                     vertexOffset,
    uint32_t                                    firstInstance);

commandBuffer is the command buffer into which the command is recorded.
indexCount is the number of vertices to draw.
instanceCount is the number of instances to draw.
firstIndex is the base index within the index buffer.
vertexOffset is the value added to the vertex index before indexing into the vertex buffer.
firstInstance is the instance ID of the first instance to draw.

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 vkCmdBindIndexBuffer::indexType parameter with which the buffer was bound.

The first vertex index is at an offset of firstIndex * indexSize + offset within the 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 VK_INDEX_TYPE_UINT8_EXT or VK_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 bound graphics pipeline.

Valid Usage

VUID-vkCmdDrawIndexed-None-02690
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
VUID-vkCmdDrawIndexed-None-02691
If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
VUID-vkCmdDrawIndexed-None-02692
If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT
VUID-vkCmdDrawIndexed-filterCubic-02694
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawIndexed-filterCubicMinmax-02695
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawIndexed-flags-02696
Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.
VUID-vkCmdDrawIndexed-None-02697
For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawIndexed-None-02698
For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawIndexed-None-02699
Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command
VUID-vkCmdDrawIndexed-None-02700
A valid pipeline must be bound to the pipeline bind point used by this command
VUID-vkCmdDrawIndexed-commandBuffer-02701
If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic
VUID-vkCmdDrawIndexed-None-02859
There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound
VUID-vkCmdDrawIndexed-None-02702
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
VUID-vkCmdDrawIndexed-None-02703
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawIndexed-None-02704
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawIndexed-None-02705
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawIndexed-None-02706
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawIndexed-commandBuffer-02707
If commandBuffer is an unprotected command buffer, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource
VUID-vkCmdDrawIndexed-renderPass-02684
The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawIndexed-subpass-02685
The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawIndexed-None-02686
Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
VUID-vkCmdDrawIndexed-None-02687
Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.
VUID-vkCmdDrawIndexed-maxMultiviewInstanceIndex-02688
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
VUID-vkCmdDrawIndexed-sampleLocationsEnable-02689
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set
VUID-vkCmdDrawIndexed-commandBuffer-02712
If commandBuffer is a protected command buffer, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource
VUID-vkCmdDrawIndexed-commandBuffer-02713
If commandBuffer is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the VkPipeline object bound to the pipeline bind point must not write to any resource
VUID-vkCmdDrawIndexed-None-02720
All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound
VUID-vkCmdDrawIndexed-None-02721
For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description
VUID-vkCmdDrawIndexed-indexSize-00463
(indexSize * (firstIndex + indexCount) + offset) must be less than or equal to the size of the bound index buffer, with indexSize being based on the type specified by indexType, where the index buffer, indexType, and offset are specified via vkCmdBindIndexBuffer

Valid Usage (Implicit)

VUID-vkCmdDrawIndexed-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdDrawIndexed-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdDrawIndexed-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdDrawIndexed-renderpass
This command must only be called inside of a render pass instance

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Inside

Graphics

To record a non-indexed indirect draw, call:

void vkCmdDrawIndirect(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    uint32_t                                    drawCount,
    uint32_t                                    stride);

commandBuffer is the command buffer into which the command is recorded.
buffer is the buffer containing draw parameters.
offset is the byte offset into buffer where parameters begin.
drawCount is the number of draws to execute, and can be zero.
stride is the byte stride between successive sets of draw parameters.

vkCmdDrawIndirect behaves similarly to vkCmdDraw 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

VUID-vkCmdDrawIndirect-None-02690
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
VUID-vkCmdDrawIndirect-None-02691
If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
VUID-vkCmdDrawIndirect-None-02692
If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT
VUID-vkCmdDrawIndirect-filterCubic-02694
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawIndirect-filterCubicMinmax-02695
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawIndirect-flags-02696
Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.
VUID-vkCmdDrawIndirect-None-02697
For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawIndirect-None-02698
For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawIndirect-None-02699
Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command
VUID-vkCmdDrawIndirect-None-02700
A valid pipeline must be bound to the pipeline bind point used by this command
VUID-vkCmdDrawIndirect-commandBuffer-02701
If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic
VUID-vkCmdDrawIndirect-None-02859
There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound
VUID-vkCmdDrawIndirect-None-02702
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
VUID-vkCmdDrawIndirect-None-02703
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawIndirect-None-02704
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawIndirect-None-02705
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawIndirect-None-02706
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawIndirect-commandBuffer-02707
If commandBuffer is an unprotected command buffer, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource
VUID-vkCmdDrawIndirect-renderPass-02684
The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawIndirect-subpass-02685
The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawIndirect-None-02686
Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
VUID-vkCmdDrawIndirect-None-02687
Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.
VUID-vkCmdDrawIndirect-maxMultiviewInstanceIndex-02688
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
VUID-vkCmdDrawIndirect-sampleLocationsEnable-02689
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set
VUID-vkCmdDrawIndirect-None-02720
All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound
VUID-vkCmdDrawIndirect-None-02721
For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description
VUID-vkCmdDrawIndirect-buffer-02708
If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdDrawIndirect-buffer-02709
buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
VUID-vkCmdDrawIndirect-offset-02710
offset must be a multiple of 4
VUID-vkCmdDrawIndirect-commandBuffer-02711
commandBuffer must not be a protected command buffer
VUID-vkCmdDrawIndirect-drawCount-02718
If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1
VUID-vkCmdDrawIndirect-drawCount-02719
drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount
VUID-vkCmdDrawIndirect-firstInstance-00478
If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndirectCommand structures accessed by this command must be 0
VUID-vkCmdDrawIndirect-drawCount-00476
If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)
VUID-vkCmdDrawIndirect-drawCount-00487
If drawCount is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer
VUID-vkCmdDrawIndirect-drawCount-00488
If drawCount is greater than 1, (stride × (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer

Valid Usage (Implicit)

VUID-vkCmdDrawIndirect-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdDrawIndirect-buffer-parameter
buffer must be a valid VkBuffer handle
VUID-vkCmdDrawIndirect-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdDrawIndirect-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdDrawIndirect-renderpass
This command must only be called inside of a render pass instance
VUID-vkCmdDrawIndirect-commonparent
Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Inside

Graphics

The VkDrawIndirectCommand structure is defined as:

typedef struct VkDrawIndirectCommand {
    uint32_t    vertexCount;
    uint32_t    instanceCount;
    uint32_t    firstVertex;
    uint32_t    firstInstance;
} VkDrawIndirectCommand;

vertexCount is the number of vertices to draw.
instanceCount is the number of instances to draw.
firstVertex is the index of the first vertex to draw.
firstInstance is the instance ID of the first instance to draw.

The members of VkDrawIndirectCommand have the same meaning as the similarly named parameters of vkCmdDraw.

Valid Usage

VUID-VkDrawIndirectCommand-None-00500
For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description
VUID-VkDrawIndirectCommand-firstInstance-00501
If the drawIndirectFirstInstance feature is not enabled, firstInstance must be 0

To record a non-indexed draw call with a draw call count sourced from a buffer, call:

void vkCmdDrawIndirectCount(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    VkBuffer                                    countBuffer,
    VkDeviceSize                                countBufferOffset,
    uint32_t                                    maxDrawCount,
    uint32_t                                    stride);

or the equivalent command

void vkCmdDrawIndirectCountKHR(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    VkBuffer                                    countBuffer,
    VkDeviceSize                                countBufferOffset,
    uint32_t                                    maxDrawCount,
    uint32_t                                    stride);

or the equivalent command

void vkCmdDrawIndirectCountAMD(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    VkBuffer                                    countBuffer,
    VkDeviceSize                                countBufferOffset,
    uint32_t                                    maxDrawCount,
    uint32_t                                    stride);

commandBuffer is the command buffer into which the command is recorded.
buffer is the buffer containing draw parameters.
offset is the byte offset into buffer where parameters begin.
countBuffer is the buffer containing the draw count.
countBufferOffset is the byte offset into countBuffer where the draw count begins.
maxDrawCount specifies the maximum number of draws that will be executed. The actual number of executed draw calls is the minimum of the count specified in countBuffer and maxDrawCount.
stride is the byte stride between successive sets of draw parameters.

vkCmdDrawIndirectCount behaves similarly to vkCmdDrawIndirect except that the draw count is read by the device from a buffer during execution. The command will read an unsigned 32-bit integer from countBuffer located at countBufferOffset and use this as the draw count.

Valid Usage

VUID-vkCmdDrawIndirectCount-None-02690
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
VUID-vkCmdDrawIndirectCount-None-02691
If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
VUID-vkCmdDrawIndirectCount-None-02692
If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT
VUID-vkCmdDrawIndirectCount-filterCubic-02694
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawIndirectCount-filterCubicMinmax-02695
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawIndirectCount-flags-02696
Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.
VUID-vkCmdDrawIndirectCount-None-02697
For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawIndirectCount-None-02698
For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawIndirectCount-None-02699
Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command
VUID-vkCmdDrawIndirectCount-None-02700
A valid pipeline must be bound to the pipeline bind point used by this command
VUID-vkCmdDrawIndirectCount-commandBuffer-02701
If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic
VUID-vkCmdDrawIndirectCount-None-02859
There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound
VUID-vkCmdDrawIndirectCount-None-02702
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
VUID-vkCmdDrawIndirectCount-None-02703
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawIndirectCount-None-02704
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawIndirectCount-None-02705
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawIndirectCount-None-02706
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawIndirectCount-commandBuffer-02707
If commandBuffer is an unprotected command buffer, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource
VUID-vkCmdDrawIndirectCount-renderPass-02684
The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawIndirectCount-subpass-02685
The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawIndirectCount-None-02686
Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
VUID-vkCmdDrawIndirectCount-None-02687
Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.
VUID-vkCmdDrawIndirectCount-maxMultiviewInstanceIndex-02688
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
VUID-vkCmdDrawIndirectCount-sampleLocationsEnable-02689
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set
VUID-vkCmdDrawIndirectCount-None-02720
All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound
VUID-vkCmdDrawIndirectCount-None-02721
For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description
VUID-vkCmdDrawIndirectCount-buffer-02708
If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdDrawIndirectCount-buffer-02709
buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
VUID-vkCmdDrawIndirectCount-offset-02710
offset must be a multiple of 4
VUID-vkCmdDrawIndirectCount-commandBuffer-02711
commandBuffer must not be a protected command buffer
VUID-vkCmdDrawIndirectCount-countBuffer-02714
If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdDrawIndirectCount-countBuffer-02715
countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
VUID-vkCmdDrawIndirectCount-countBufferOffset-02716
countBufferOffset must be a multiple of 4
VUID-vkCmdDrawIndirectCount-countBuffer-02717
The count stored in countBuffer must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount
VUID-vkCmdDrawIndirectCount-stride-03110
stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)
VUID-vkCmdDrawIndirectCount-maxDrawCount-03111
If maxDrawCount is greater than or equal to 1, (stride × (maxDrawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer
VUID-vkCmdDrawIndirectCount-countBuffer-03121
If the count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer
VUID-vkCmdDrawIndirectCount-countBuffer-03122
If the count stored in countBuffer is greater than 1, (stride × (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer
VUID-vkCmdDrawIndirectCount-None-02836
If drawIndirectCount is not enabled this function must not be used

Valid Usage (Implicit)

VUID-vkCmdDrawIndirectCount-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdDrawIndirectCount-buffer-parameter
buffer must be a valid VkBuffer handle
VUID-vkCmdDrawIndirectCount-countBuffer-parameter
countBuffer must be a valid VkBuffer handle
VUID-vkCmdDrawIndirectCount-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdDrawIndirectCount-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdDrawIndirectCount-renderpass
This command must only be called inside of a render pass instance
VUID-vkCmdDrawIndirectCount-commonparent
Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Inside

Graphics

To record an indexed indirect draw, call:

void vkCmdDrawIndexedIndirect(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    uint32_t                                    drawCount,
    uint32_t                                    stride);

commandBuffer is the command buffer into which the command is recorded.
buffer is the buffer containing draw parameters.
offset is the byte offset into buffer where parameters begin.
drawCount is the number of draws to execute, and can be zero.
stride is the byte stride between successive sets of draw parameters.

vkCmdDrawIndexedIndirect behaves similarly to vkCmdDrawIndexed 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

VUID-vkCmdDrawIndexedIndirect-None-02690
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
VUID-vkCmdDrawIndexedIndirect-None-02691
If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
VUID-vkCmdDrawIndexedIndirect-None-02692
If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT
VUID-vkCmdDrawIndexedIndirect-filterCubic-02694
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawIndexedIndirect-filterCubicMinmax-02695
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawIndexedIndirect-flags-02696
Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.
VUID-vkCmdDrawIndexedIndirect-None-02697
For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawIndexedIndirect-None-02698
For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawIndexedIndirect-None-02699
Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command
VUID-vkCmdDrawIndexedIndirect-None-02700
A valid pipeline must be bound to the pipeline bind point used by this command
VUID-vkCmdDrawIndexedIndirect-commandBuffer-02701
If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic
VUID-vkCmdDrawIndexedIndirect-None-02859
There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound
VUID-vkCmdDrawIndexedIndirect-None-02702
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
VUID-vkCmdDrawIndexedIndirect-None-02703
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawIndexedIndirect-None-02704
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawIndexedIndirect-None-02705
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawIndexedIndirect-None-02706
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawIndexedIndirect-commandBuffer-02707
If commandBuffer is an unprotected command buffer, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource
VUID-vkCmdDrawIndexedIndirect-renderPass-02684
The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawIndexedIndirect-subpass-02685
The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawIndexedIndirect-None-02686
Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
VUID-vkCmdDrawIndexedIndirect-None-02687
Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.
VUID-vkCmdDrawIndexedIndirect-maxMultiviewInstanceIndex-02688
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
VUID-vkCmdDrawIndexedIndirect-sampleLocationsEnable-02689
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set
VUID-vkCmdDrawIndexedIndirect-None-02720
All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound
VUID-vkCmdDrawIndexedIndirect-None-02721
For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description
VUID-vkCmdDrawIndexedIndirect-buffer-02708
If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdDrawIndexedIndirect-buffer-02709
buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
VUID-vkCmdDrawIndexedIndirect-offset-02710
offset must be a multiple of 4
VUID-vkCmdDrawIndexedIndirect-commandBuffer-02711
commandBuffer must not be a protected command buffer
VUID-vkCmdDrawIndexedIndirect-drawCount-02718
If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1
VUID-vkCmdDrawIndexedIndirect-drawCount-02719
drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount
VUID-vkCmdDrawIndexedIndirect-drawCount-00528
If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndexedIndirectCommand)
VUID-vkCmdDrawIndexedIndirect-firstInstance-00530
If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndexedIndirectCommand structures accessed by this command must be 0
VUID-vkCmdDrawIndexedIndirect-drawCount-00539
If drawCount is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer
VUID-vkCmdDrawIndexedIndirect-drawCount-00540
If drawCount is greater than 1, (stride × (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer
VUID-vkCmdDrawIndexedIndirect-None-02837
If drawIndirectCount is not enabled this function must not be used

Valid Usage (Implicit)

VUID-vkCmdDrawIndexedIndirect-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdDrawIndexedIndirect-buffer-parameter
buffer must be a valid VkBuffer handle
VUID-vkCmdDrawIndexedIndirect-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdDrawIndexedIndirect-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdDrawIndexedIndirect-renderpass
This command must only be called inside of a render pass instance
VUID-vkCmdDrawIndexedIndirect-commonparent
Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Inside

Graphics

The VkDrawIndexedIndirectCommand structure is defined as:

typedef struct VkDrawIndexedIndirectCommand {
    uint32_t    indexCount;
    uint32_t    instanceCount;
    uint32_t    firstIndex;
    int32_t     vertexOffset;
    uint32_t    firstInstance;
} VkDrawIndexedIndirectCommand;

indexCount is the number of vertices to draw.
instanceCount is the number of instances to draw.
firstIndex is the base index within the index buffer.
vertexOffset is the value added to the vertex index before indexing into the vertex buffer.
firstInstance is the instance ID of the first instance to draw.

The members of VkDrawIndexedIndirectCommand have the same meaning as the similarly named parameters of vkCmdDrawIndexed.

Valid Usage

VUID-VkDrawIndexedIndirectCommand-None-00552
For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description
VUID-VkDrawIndexedIndirectCommand-indexSize-00553
(indexSize * (firstIndex + indexCount) + offset) must be less than or equal to the size of the bound index buffer, with indexSize being based on the type specified by indexType, where the index buffer, indexType, and offset are specified via vkCmdBindIndexBuffer
VUID-VkDrawIndexedIndirectCommand-firstInstance-00554
If the drawIndirectFirstInstance feature is not enabled, firstInstance must be 0

To record an indexed draw call with a draw call count sourced from a buffer, call:

void vkCmdDrawIndexedIndirectCount(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    VkBuffer                                    countBuffer,
    VkDeviceSize                                countBufferOffset,
    uint32_t                                    maxDrawCount,
    uint32_t                                    stride);

or the equivalent command

void vkCmdDrawIndexedIndirectCountKHR(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    VkBuffer                                    countBuffer,
    VkDeviceSize                                countBufferOffset,
    uint32_t                                    maxDrawCount,
    uint32_t                                    stride);

or the equivalent command

void vkCmdDrawIndexedIndirectCountAMD(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    VkBuffer                                    countBuffer,
    VkDeviceSize                                countBufferOffset,
    uint32_t                                    maxDrawCount,
    uint32_t                                    stride);

commandBuffer is the command buffer into which the command is recorded.
buffer is the buffer containing draw parameters.
offset is the byte offset into buffer where parameters begin.
countBuffer is the buffer containing the draw count.
countBufferOffset is the byte offset into countBuffer where the draw count begins.
maxDrawCount specifies the maximum number of draws that will be executed. The actual number of executed draw calls is the minimum of the count specified in countBuffer and maxDrawCount.
stride is the byte stride between successive sets of draw parameters.

vkCmdDrawIndexedIndirectCount behaves similarly to vkCmdDrawIndexedIndirect except that the draw count is read by the device from a buffer during execution. The command will read an unsigned 32-bit integer from countBuffer located at countBufferOffset and use this as the draw count.

Valid Usage

VUID-vkCmdDrawIndexedIndirectCount-None-02690
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
VUID-vkCmdDrawIndexedIndirectCount-None-02691
If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
VUID-vkCmdDrawIndexedIndirectCount-None-02692
If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT
VUID-vkCmdDrawIndexedIndirectCount-filterCubic-02694
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawIndexedIndirectCount-filterCubicMinmax-02695
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawIndexedIndirectCount-flags-02696
Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.
VUID-vkCmdDrawIndexedIndirectCount-None-02697
For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawIndexedIndirectCount-None-02698
For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawIndexedIndirectCount-None-02699
Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command
VUID-vkCmdDrawIndexedIndirectCount-None-02700
A valid pipeline must be bound to the pipeline bind point used by this command
VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02701
If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic
VUID-vkCmdDrawIndexedIndirectCount-None-02859
There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound
VUID-vkCmdDrawIndexedIndirectCount-None-02702
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
VUID-vkCmdDrawIndexedIndirectCount-None-02703
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawIndexedIndirectCount-None-02704
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawIndexedIndirectCount-None-02705
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawIndexedIndirectCount-None-02706
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02707
If commandBuffer is an unprotected command buffer, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource
VUID-vkCmdDrawIndexedIndirectCount-renderPass-02684
The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawIndexedIndirectCount-subpass-02685
The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawIndexedIndirectCount-None-02686
Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
VUID-vkCmdDrawIndexedIndirectCount-None-02687
Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.
VUID-vkCmdDrawIndexedIndirectCount-maxMultiviewInstanceIndex-02688
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
VUID-vkCmdDrawIndexedIndirectCount-sampleLocationsEnable-02689
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set
VUID-vkCmdDrawIndexedIndirectCount-None-02720
All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound
VUID-vkCmdDrawIndexedIndirectCount-None-02721
For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description
VUID-vkCmdDrawIndexedIndirectCount-buffer-02708
If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdDrawIndexedIndirectCount-buffer-02709
buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
VUID-vkCmdDrawIndexedIndirectCount-offset-02710
offset must be a multiple of 4
VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02711
commandBuffer must not be a protected command buffer
VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02714
If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02715
countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
VUID-vkCmdDrawIndexedIndirectCount-countBufferOffset-02716
countBufferOffset must be a multiple of 4
VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02717
The count stored in countBuffer must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount
VUID-vkCmdDrawIndexedIndirectCount-stride-03142
stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndexedIndirectCommand)
VUID-vkCmdDrawIndexedIndirectCount-maxDrawCount-03143
If maxDrawCount is greater than or equal to 1, (stride × (maxDrawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer
VUID-vkCmdDrawIndexedIndirectCount-countBuffer-03153
If count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer
VUID-vkCmdDrawIndexedIndirectCount-countBuffer-03154
If count stored in countBuffer is greater than 1, (stride × (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer

Valid Usage (Implicit)

VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdDrawIndexedIndirectCount-buffer-parameter
buffer must be a valid VkBuffer handle
VUID-vkCmdDrawIndexedIndirectCount-countBuffer-parameter
countBuffer must be a valid VkBuffer handle
VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdDrawIndexedIndirectCount-renderpass
This command must only be called inside of a render pass instance
VUID-vkCmdDrawIndexedIndirectCount-commonparent
Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Inside

Graphics

20.3.1. Drawing Transform Feedback

It is possible to draw vertex data that was previously captured during active transform feedback by binding one or more of the transform feedback buffers as vertex buffers. A pipeline barrier is required between using the buffers as transform feedback buffers and vertex buffers to ensure all writes to the transform feedback buffers are visible when the data is read as vertex attributes. The source access is VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT and the destination access is VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT for the pipeline stages VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT and VK_PIPELINE_STAGE_VERTEX_INPUT_BIT respectively. The value written to the counter buffer by vkCmdEndTransformFeedbackEXT can be used to determine the vertex count for the draw. A pipeline barrier is required between using the counter buffer for vkCmdEndTransformFeedbackEXT and vkCmdDrawIndirectByteCountEXT where the source access is VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT and the destination access is VK_ACCESS_INDIRECT_COMMAND_READ_BIT for the pipeline stages VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT and VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT respectively.

To record a non-indexed draw call, where the vertex count is based on a byte count read from a buffer and the passed in vertex stride parameter, call:

void vkCmdDrawIndirectByteCountEXT(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    instanceCount,
    uint32_t                                    firstInstance,
    VkBuffer                                    counterBuffer,
    VkDeviceSize                                counterBufferOffset,
    uint32_t                                    counterOffset,
    uint32_t                                    vertexStride);

commandBuffer is the command buffer into which the command is recorded.
instanceCount is the number of instances to draw.
firstInstance is the instance ID of the first instance to draw.
counterBuffer is the buffer handle from where the byte count is read.
counterBufferOffset is the offset into the buffer used to read the byte count, which is used to calculate the vertex count for this draw call.
counterOffset is subtracted from the byte count read from the counterBuffer at the counterBufferOffset
vertexStride is the stride in bytes between each element of the vertex data that is used to calculate the vertex count from the counter value. This value is typically the same value that was used in the graphics pipeline state when the transform feedback was captured as the XfbStride.

When the command is executed, primitives are assembled in the same way as done with vkCmdDraw except the vertexCount is calculated based on the byte count read from counterBuffer at offset counterBufferOffset. The assembled primitives execute the bound graphics pipeline.

The effective vertexCount is calculated as follows:

const uint32_t * counterBufferPtr = (const uint8_t *)counterBuffer.address + counterBufferOffset;
vertexCount = floor(max(0, (*counterBufferPtr - counterOffset)) / vertexStride);

The effective firstVertex is zero.

Valid Usage

VUID-vkCmdDrawIndirectByteCountEXT-None-02690
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
VUID-vkCmdDrawIndirectByteCountEXT-None-02691
If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
VUID-vkCmdDrawIndirectByteCountEXT-None-02692
If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT
VUID-vkCmdDrawIndirectByteCountEXT-filterCubic-02694
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawIndirectByteCountEXT-filterCubicMinmax-02695
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawIndirectByteCountEXT-flags-02696
Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.
VUID-vkCmdDrawIndirectByteCountEXT-None-02697
For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawIndirectByteCountEXT-None-02698
For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawIndirectByteCountEXT-None-02699
Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command
VUID-vkCmdDrawIndirectByteCountEXT-None-02700
A valid pipeline must be bound to the pipeline bind point used by this command
VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-02701
If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic
VUID-vkCmdDrawIndirectByteCountEXT-None-02859
There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound
VUID-vkCmdDrawIndirectByteCountEXT-None-02702
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
VUID-vkCmdDrawIndirectByteCountEXT-None-02703
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawIndirectByteCountEXT-None-02704
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawIndirectByteCountEXT-None-02705
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawIndirectByteCountEXT-None-02706
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-02707
If commandBuffer is an unprotected command buffer, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource
VUID-vkCmdDrawIndirectByteCountEXT-renderPass-02684
The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawIndirectByteCountEXT-subpass-02685
The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawIndirectByteCountEXT-None-02686
Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
VUID-vkCmdDrawIndirectByteCountEXT-None-02687
Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.
VUID-vkCmdDrawIndirectByteCountEXT-maxMultiviewInstanceIndex-02688
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
VUID-vkCmdDrawIndirectByteCountEXT-sampleLocationsEnable-02689
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set
VUID-vkCmdDrawIndirectByteCountEXT-None-02720
All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound
VUID-vkCmdDrawIndirectByteCountEXT-None-02721
For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description
VUID-vkCmdDrawIndirectByteCountEXT-transformFeedback-02287
VkPhysicalDeviceTransformFeedbackFeaturesEXT::transformFeedback must be enabled
VUID-vkCmdDrawIndirectByteCountEXT-transformFeedbackDraw-02288
The implementation must support VkPhysicalDeviceTransformFeedbackPropertiesEXT::transformFeedbackDraw
VUID-vkCmdDrawIndirectByteCountEXT-vertexStride-02289
vertexStride must be greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxTransformFeedbackBufferDataStride
VUID-vkCmdDrawIndirectByteCountEXT-counterBuffer-02290
counterBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-02646
commandBuffer must not be a protected command buffer

Valid Usage (Implicit)

VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdDrawIndirectByteCountEXT-counterBuffer-parameter
counterBuffer must be a valid VkBuffer handle
VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdDrawIndirectByteCountEXT-renderpass
This command must only be called inside of a render pass instance
VUID-vkCmdDrawIndirectByteCountEXT-commonparent
Both of commandBuffer, and counterBuffer must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Inside

Graphics

20.4. Conditional Rendering

Certain rendering commands can be executed conditionally based on a value in buffer memory. These rendering commands are limited to drawing commands, dispatching commands, and clearing attachments with vkCmdClearAttachments within a conditional rendering block which is defined by commands vkCmdBeginConditionalRenderingEXT and vkCmdEndConditionalRenderingEXT. Other rendering commands remain unaffected by conditional rendering.

After beginning conditional rendering, it is considered active within the command buffer it was called until it is ended with vkCmdEndConditionalRenderingEXT.

Conditional rendering must begin and end in the same command buffer. When conditional rendering is active, a primary command buffer can execute secondary command buffers if the inherited conditional rendering feature is enabled. For a secondary command buffer to be executed while conditional rendering is active in the primary command buffer, it must set the conditionalRenderingEnable flag of VkCommandBufferInheritanceConditionalRenderingInfoEXT, as described in the Command Buffer Recording section.

Conditional rendering must also 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).

To begin conditional rendering, call:

void vkCmdBeginConditionalRenderingEXT(
    VkCommandBuffer                             commandBuffer,
    const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin);

commandBuffer is the command buffer into which this command will be recorded.
pConditionalRenderingBegin is a pointer to a VkConditionalRenderingBeginInfoEXT structure specifying parameters of conditional rendering.

Valid Usage

VUID-vkCmdBeginConditionalRenderingEXT-None-01980
Conditional rendering must not already be active

Valid Usage (Implicit)

VUID-vkCmdBeginConditionalRenderingEXT-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdBeginConditionalRenderingEXT-pConditionalRenderingBegin-parameter
pConditionalRenderingBegin must be a valid pointer to a valid VkConditionalRenderingBeginInfoEXT structure
VUID-vkCmdBeginConditionalRenderingEXT-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdBeginConditionalRenderingEXT-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

The VkConditionalRenderingBeginInfoEXT structure is defined as:

typedef struct VkConditionalRenderingBeginInfoEXT {
    VkStructureType                   sType;
    const void*                       pNext;
    VkBuffer                          buffer;
    VkDeviceSize                      offset;
    VkConditionalRenderingFlagsEXT    flags;
} VkConditionalRenderingBeginInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
buffer is a buffer containing the predicate for conditional rendering.
offset is the byte offset into buffer where the predicate is located.
flags is a bitmask of VkConditionalRenderingFlagsEXT specifying the behavior of conditional rendering.

If the 32-bit value at offset in buffer memory is zero, then the rendering commands are discarded, otherwise they are executed as normal. If the value of the predicate in buffer memory changes while conditional rendering is active, the rendering commands may be discarded in an implementation-dependent way. Some implementations may latch the value of the predicate upon beginning conditional rendering while others may read it before every rendering command.

Valid Usage

VUID-VkConditionalRenderingBeginInfoEXT-buffer-01981
If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-VkConditionalRenderingBeginInfoEXT-buffer-01982
buffer must have been created with the VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT bit set
VUID-VkConditionalRenderingBeginInfoEXT-offset-01983
offset must be less than the size of buffer by at least 32 bits.
VUID-VkConditionalRenderingBeginInfoEXT-offset-01984
offset must be a multiple of 4

Valid Usage (Implicit)

VUID-VkConditionalRenderingBeginInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT
VUID-VkConditionalRenderingBeginInfoEXT-pNext-pNext
pNext must be NULL
VUID-VkConditionalRenderingBeginInfoEXT-buffer-parameter
buffer must be a valid VkBuffer handle
VUID-VkConditionalRenderingBeginInfoEXT-flags-parameter
flags must be a valid combination of VkConditionalRenderingFlagBitsEXT values

Bits which can be set in vkCmdBeginConditionalRenderingEXT::flags specifying the behavior of conditional rendering are:

typedef enum VkConditionalRenderingFlagBitsEXT {
    VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001,
    VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
} VkConditionalRenderingFlagBitsEXT;

VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT specifies the condition used to determine whether to discard rendering commands or not. That is, if the 32-bit predicate read from buffer memory at offset is zero, the rendering commands are not discarded, and if non zero, then they are discarded.

typedef VkFlags VkConditionalRenderingFlagsEXT;

VkConditionalRenderingFlagsEXT is a bitmask type for setting a mask of zero or more VkConditionalRenderingFlagBitsEXT.

To end conditional rendering, call:

void vkCmdEndConditionalRenderingEXT(
    VkCommandBuffer                             commandBuffer);

commandBuffer is the command buffer into which this command will be recorded.

Once ended, conditional rendering becomes inactive.

Valid Usage

VUID-vkCmdEndConditionalRenderingEXT-None-01985
Conditional rendering must be active
VUID-vkCmdEndConditionalRenderingEXT-None-01986
If conditional rendering was made active outside of a render pass instance, it must not be ended inside a render pass instance
VUID-vkCmdEndConditionalRenderingEXT-None-01987
If conditional rendering was made active within a subpass it must be ended in the same subpass

Valid Usage (Implicit)

VUID-vkCmdEndConditionalRenderingEXT-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdEndConditionalRenderingEXT-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdEndConditionalRenderingEXT-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

20.5. Programmable Mesh Shading

In this drawing approach, primitives are assembled by the mesh shader stage. Mesh shading operates similarly to dispatching compute as the shaders make use of workgroups.

To record a draw that uses the mesh pipeline, call:

void vkCmdDrawMeshTasksNV(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    taskCount,
    uint32_t                                    firstTask);

commandBuffer is the command buffer into which the command will be recorded.
taskCount is the number of local workgroups to dispatch in the X dimension. Y and Z dimension are implicitly set to one.
firstTask is the X component of the first workgroup ID.

When the command is executed, a global workgroup consisting of taskCount local workgroups is assembled.

Valid Usage

VUID-vkCmdDrawMeshTasksNV-None-02690
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
VUID-vkCmdDrawMeshTasksNV-None-02691
If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
VUID-vkCmdDrawMeshTasksNV-None-02692
If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT
VUID-vkCmdDrawMeshTasksNV-filterCubic-02694
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawMeshTasksNV-filterCubicMinmax-02695
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawMeshTasksNV-flags-02696
Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.
VUID-vkCmdDrawMeshTasksNV-None-02697
For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawMeshTasksNV-None-02698
For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawMeshTasksNV-None-02699
Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command
VUID-vkCmdDrawMeshTasksNV-None-02700
A valid pipeline must be bound to the pipeline bind point used by this command
VUID-vkCmdDrawMeshTasksNV-commandBuffer-02701
If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic
VUID-vkCmdDrawMeshTasksNV-None-02859
There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound
VUID-vkCmdDrawMeshTasksNV-None-02702
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
VUID-vkCmdDrawMeshTasksNV-None-02703
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawMeshTasksNV-None-02704
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawMeshTasksNV-None-02705
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawMeshTasksNV-None-02706
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawMeshTasksNV-commandBuffer-02707
If commandBuffer is an unprotected command buffer, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource
VUID-vkCmdDrawMeshTasksNV-renderPass-02684
The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawMeshTasksNV-subpass-02685
The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawMeshTasksNV-None-02686
Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
VUID-vkCmdDrawMeshTasksNV-None-02687
Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.
VUID-vkCmdDrawMeshTasksNV-maxMultiviewInstanceIndex-02688
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
VUID-vkCmdDrawMeshTasksNV-sampleLocationsEnable-02689
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set
VUID-vkCmdDrawMeshTasksNV-taskCount-02119
taskCount must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxDrawMeshTasksCount

Valid Usage (Implicit)

VUID-vkCmdDrawMeshTasksNV-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdDrawMeshTasksNV-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdDrawMeshTasksNV-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdDrawMeshTasksNV-renderpass
This command must only be called inside of a render pass instance

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Inside

Graphics

To record an indirect mesh tasks draw, call:

void vkCmdDrawMeshTasksIndirectNV(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    uint32_t                                    drawCount,
    uint32_t                                    stride);

commandBuffer is the command buffer into which the command is recorded.
buffer is the buffer containing draw parameters.
offset is the byte offset into buffer where parameters begin.
drawCount is the number of draws to execute, and can be zero.
stride is the byte stride between successive sets of draw parameters.

vkCmdDrawMeshTasksIndirectNV behaves similarly to vkCmdDrawMeshTasksNV 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 VkDrawMeshTasksIndirectCommandNV structures. If drawCount is less than or equal to one, stride is ignored.

Valid Usage

VUID-vkCmdDrawMeshTasksIndirectNV-None-02690
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
VUID-vkCmdDrawMeshTasksIndirectNV-None-02691
If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
VUID-vkCmdDrawMeshTasksIndirectNV-None-02692
If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT
VUID-vkCmdDrawMeshTasksIndirectNV-filterCubic-02694
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawMeshTasksIndirectNV-filterCubicMinmax-02695
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawMeshTasksIndirectNV-flags-02696
Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.
VUID-vkCmdDrawMeshTasksIndirectNV-None-02697
For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawMeshTasksIndirectNV-None-02698
For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawMeshTasksIndirectNV-None-02699
Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command
VUID-vkCmdDrawMeshTasksIndirectNV-None-02700
A valid pipeline must be bound to the pipeline bind point used by this command
VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-02701
If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic
VUID-vkCmdDrawMeshTasksIndirectNV-None-02859
There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound
VUID-vkCmdDrawMeshTasksIndirectNV-None-02702
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
VUID-vkCmdDrawMeshTasksIndirectNV-None-02703
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawMeshTasksIndirectNV-None-02704
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawMeshTasksIndirectNV-None-02705
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawMeshTasksIndirectNV-None-02706
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-02707
If commandBuffer is an unprotected command buffer, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource
VUID-vkCmdDrawMeshTasksIndirectNV-renderPass-02684
The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawMeshTasksIndirectNV-subpass-02685
The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawMeshTasksIndirectNV-None-02686
Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
VUID-vkCmdDrawMeshTasksIndirectNV-None-02687
Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.
VUID-vkCmdDrawMeshTasksIndirectNV-maxMultiviewInstanceIndex-02688
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
VUID-vkCmdDrawMeshTasksIndirectNV-sampleLocationsEnable-02689
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set
VUID-vkCmdDrawMeshTasksIndirectNV-buffer-02708
If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdDrawMeshTasksIndirectNV-buffer-02709
buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
VUID-vkCmdDrawMeshTasksIndirectNV-offset-02710
offset must be a multiple of 4
VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-02711
commandBuffer must not be a protected command buffer
VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02718
If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1
VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02719
drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount
VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02146
If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawMeshTasksIndirectCommandNV)
VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02156
If drawCount is equal to 1, (offset + sizeof(VkDrawMeshTasksIndirectCommandNV)) must be less than or equal to the size of buffer
VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02157
If drawCount is greater than 1, (stride × (drawCount - 1) + offset + sizeof(VkDrawMeshTasksIndirectCommandNV)) must be less than or equal to the size of buffer

Valid Usage (Implicit)

VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdDrawMeshTasksIndirectNV-buffer-parameter
buffer must be a valid VkBuffer handle
VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdDrawMeshTasksIndirectNV-renderpass
This command must only be called inside of a render pass instance
VUID-vkCmdDrawMeshTasksIndirectNV-commonparent
Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Inside

Graphics

The VkDrawMeshTasksIndirectCommandNV structure is defined as:

typedef struct VkDrawMeshTasksIndirectCommandNV {
    uint32_t    taskCount;
    uint32_t    firstTask;
} VkDrawMeshTasksIndirectCommandNV;

taskCount is the number of local workgroups to dispatch in the X dimension. Y and Z dimension are implicitly set to one.
firstTask is the X component of the first workgroup ID.

The members of VkDrawMeshTasksIndirectCommandNV have the same meaning as the similarly named parameters of vkCmdDrawMeshTasksNV.

Valid Usage

VUID-VkDrawMeshTasksIndirectCommandNV-taskCount-02175
taskCount must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxDrawMeshTasksCount

To record an indirect mesh tasks draw with the draw count sourced from a buffer, call:

void vkCmdDrawMeshTasksIndirectCountNV(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    VkBuffer                                    countBuffer,
    VkDeviceSize                                countBufferOffset,
    uint32_t                                    maxDrawCount,
    uint32_t                                    stride);

commandBuffer is the command buffer into which the command is recorded.
buffer is the buffer containing draw parameters.
offset is the byte offset into buffer where parameters begin.
countBuffer is the buffer containing the draw count.
countBufferOffset is the byte offset into countBuffer where the draw count begins.
maxDrawCount specifies the maximum number of draws that will be executed. The actual number of executed draw calls is the minimum of the count specified in countBuffer and maxDrawCount.
stride is the byte stride between successive sets of draw parameters.

vkCmdDrawMeshTasksIndirectCountNV behaves similarly to vkCmdDrawMeshTasksIndirectNV except that the draw count is read by the device from a buffer during execution. The command will read an unsigned 32-bit integer from countBuffer located at countBufferOffset and use this as the draw count.

Valid Usage

VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02690
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02691
If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02692
If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT
VUID-vkCmdDrawMeshTasksIndirectCountNV-filterCubic-02694
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawMeshTasksIndirectCountNV-filterCubicMinmax-02695
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDrawMeshTasksIndirectCountNV-flags-02696
Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.
VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02697
For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02698
For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02699
Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command
VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02700
A valid pipeline must be bound to the pipeline bind point used by this command
VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-02701
If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic
VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02859
There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound
VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02702
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02703
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02704
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02705
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02706
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-02707
If commandBuffer is an unprotected command buffer, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource
VUID-vkCmdDrawMeshTasksIndirectCountNV-renderPass-02684
The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawMeshTasksIndirectCountNV-subpass-02685
The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02686
Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02687
Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.
VUID-vkCmdDrawMeshTasksIndirectCountNV-maxMultiviewInstanceIndex-02688
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
VUID-vkCmdDrawMeshTasksIndirectCountNV-sampleLocationsEnable-02689
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set
VUID-vkCmdDrawMeshTasksIndirectCountNV-buffer-02708
If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdDrawMeshTasksIndirectCountNV-buffer-02709
buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
VUID-vkCmdDrawMeshTasksIndirectCountNV-offset-02710
offset must be a multiple of 4
VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-02711
commandBuffer must not be a protected command buffer
VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-02714
If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-02715
countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
VUID-vkCmdDrawMeshTasksIndirectCountNV-countBufferOffset-02716
countBufferOffset must be a multiple of 4
VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-02717
The count stored in countBuffer must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount
VUID-vkCmdDrawMeshTasksIndirectCountNV-stride-02182
stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawMeshTasksIndirectCommandNV)
VUID-vkCmdDrawMeshTasksIndirectCountNV-maxDrawCount-02183
If maxDrawCount is greater than or equal to 1, (stride × (maxDrawCount - 1) + offset + sizeof(VkDrawMeshTasksIndirectCommandNV)) must be less than or equal to the size of buffer
VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-02191
If the count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawMeshTasksIndirectCommandNV)) must be less than or equal to the size of buffer
VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-02192
If the count stored in countBuffer is greater than 1, (stride × (drawCount - 1) + offset + sizeof(VkDrawMeshTasksIndirectCommandNV)) must be less than or equal to the size of buffer

Valid Usage (Implicit)

VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdDrawMeshTasksIndirectCountNV-buffer-parameter
buffer must be a valid VkBuffer handle
VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-parameter
countBuffer must be a valid VkBuffer handle
VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdDrawMeshTasksIndirectCountNV-renderpass
This command must only be called inside of a render pass instance
VUID-vkCmdDrawMeshTasksIndirectCountNV-commonparent
Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Inside

Graphics

21. Fixed-Function Vertex Processing

Vertex fetching is controlled via configurable state, as a logically distinct graphics pipeline stage.

21.1. Vertex Attributes

Vertex shaders can define input variables, which receive vertex attribute data transferred from one or more VkBuffer(s) by drawing commands. Vertex shader input variables are bound to buffers via an indirect binding where the vertex shader associates a vertex input attribute number with each variable, vertex input attributes are associated to vertex input bindings on a per-pipeline basis, and vertex input bindings are associated with specific buffers on a per-draw basis via the vkCmdBindVertexBuffers command. Vertex input attribute and vertex input binding descriptions also contain format information controlling how data is extracted from buffer memory and converted to the format expected by the vertex shader.

There are VkPhysicalDeviceLimits::maxVertexInputAttributes number of vertex input attributes and VkPhysicalDeviceLimits::maxVertexInputBindings number of vertex input bindings (each referred to by zero-based indices), where there are at least as many vertex input attributes as there are vertex input bindings. Applications can store multiple vertex input attributes interleaved in a single buffer, and use a single vertex input binding to access those attributes.

In GLSL, vertex shaders associate input variables with a vertex input attribute number using the location layout qualifier. The component layout qualifier associates components of a vertex shader input variable with components of a vertex input attribute.

GLSL example

// Assign location M to variableName
layout (location=M, component=2) in vec2 variableName;

// Assign locations [N,N+L) to the array elements of variableNameArray
layout (location=N) in vec4 variableNameArray[L];

In SPIR-V, vertex shaders associate input variables with a vertex input attribute number using the Location decoration. The Component decoration associates components of a vertex shader input variable with components of a vertex input attribute. The Location and Component decorations are specified via the OpDecorate instruction.

SPIR-V example

               ...
          %1 = OpExtInstImport "GLSL.std.450"
               ...
               OpName %9 "variableName"
               OpName %15 "variableNameArray"
               OpDecorate %18 BuiltIn VertexIndex
               OpDecorate %19 BuiltIn InstanceIndex
               OpDecorate %9 Location M
               OpDecorate %9 Component 2
               OpDecorate %15 Location N
               ...
          %2 = OpTypeVoid
          %3 = OpTypeFunction %2
          %6 = OpTypeFloat 32
          %7 = OpTypeVector %6 2
          %8 = OpTypePointer Input %7
          %9 = OpVariable %8 Input
         %10 = OpTypeVector %6 4
         %11 = OpTypeInt 32 0
         %12 = OpConstant %11 L
         %13 = OpTypeArray %10 %12
         %14 = OpTypePointer Input %13
         %15 = OpVariable %14 Input
               ...

21.1.1. Attribute Location and Component Assignment

Vertex shaders allow Location and Component decorations on input variable declarations. The Location decoration specifies which vertex input attribute is used to read and interpret the data that a variable will consume. The Component decoration allows the location to be more finely specified for scalars and vectors, down to the individual components within a location that are consumed. The components within a location are 0, 1, 2, and 3. A variable starting at component N will consume components N, N+1, N+2, … up through its size. For single precision types, it is invalid if the sequence of components gets larger than 3.

When a vertex shader input variable declared using a scalar or vector 32-bit data type is assigned a location, its value(s) are taken from the components of the input attribute specified with the corresponding VkVertexInputAttributeDescription::location. The components used depend on the type of variable and the Component decoration specified in the variable declaration, as identified in Input attribute components accessed by 32-bit input variables. Any 32-bit scalar or vector input will consume a single location. For 32-bit data types, missing components are filled in with default values as described below.

Table 28. Input attribute components accessed by 32-bit input variables
32-bit data type	`Component` decoration	Components consumed
scalar	0 or unspecified	(x, o, o, o)
scalar	1	(o, y, o, o)
scalar	2	(o, o, z, o)
scalar	3	(o, o, o, w)
two-component vector	0 or unspecified	(x, y, o, o)
two-component vector	1	(o, y, z, o)
two-component vector	2	(o, o, z, w)
three-component vector	0 or unspecified	(x, y, z, o)
three-component vector	1	(o, y, z, w)
four-component vector	0 or unspecified	(x, y, z, w)

Components indicated by “o” are available for use by other input variables which are sourced from the same attribute, and if used, are either filled with the corresponding component from the input format (if present), or the default value.

When a vertex shader input variable declared using a 32-bit floating point matrix type is assigned a location i, its values are taken from consecutive input attributes starting with the corresponding VkVertexInputAttributeDescription::location. Such matrices are treated as an array of column vectors with values taken from the input attributes identified in Input attributes accessed by 32-bit input matrix variables. The VkVertexInputAttributeDescription::format must be specified with a VkFormat that corresponds to the appropriate type of column vector. The Component decoration must not be used with matrix types.

Table 29. Input attributes accessed by 32-bit input matrix variables
Data type	Column vector type	Locations consumed	Components consumed
mat2	two-component vector	i, i+1	(x, y, o, o), (x, y, o, o)
mat2x3	three-component vector	i, i+1	(x, y, z, o), (x, y, z, o)
mat2x4	four-component vector	i, i+1	(x, y, z, w), (x, y, z, w)
mat3x2	two-component vector	i, i+1, i+2	(x, y, o, o), (x, y, o, o), (x, y, o, o)
mat3	three-component vector	i, i+1, i+2	(x, y, z, o), (x, y, z, o), (x, y, z, o)
mat3x4	four-component vector	i, i+1, i+2	(x, y, z, w), (x, y, z, w), (x, y, z, w)
mat4x2	two-component vector	i, i+1, i+2, i+3	(x, y, o, o), (x, y, o, o), (x, y, o, o), (x, y, o, o)
mat4x3	three-component vector	i, i+1, i+2, i+3	(x, y, z, o), (x, y, z, o), (x, y, z, o), (x, y, z, o)
mat4	four-component vector	i, i+1, i+2, i+3	(x, y, z, w), (x, y, z, w), (x, y, z, w), (x, y, z, w)

When a vertex shader input variable declared using a scalar or vector 64-bit data type is assigned a location i, its values are taken from consecutive input attributes starting with the corresponding VkVertexInputAttributeDescription::location. The locations and components used depend on the type of variable and the Component decoration specified in the variable declaration, as identified in Input attribute locations and components accessed by 64-bit input variables. For 64-bit data types, no default attribute values are provided. Input variables must not use more components than provided by the attribute. Input attributes which have one- or two-component 64-bit formats will consume a single location. Input attributes which have three- or four-component 64-bit formats will consume two consecutive locations. A 64-bit scalar data type will consume two components, and a 64-bit two-component vector data type will consume all four components available within a location. A three- or four-component 64-bit data type must not specify a component. A three-component 64-bit data type will consume all four components of the first location and components 0 and 1 of the second location. This leaves components 2 and 3 available for other component-qualified declarations. A four-component 64-bit data type will consume all four components of the first location and all four components of the second location. It is invalid for a scalar or two-component 64-bit data type to specify a component of 1 or 3.

Table 30. Input attribute locations and components accessed by 64-bit input variables
Input format	Locations consumed	64-bit data type	`Location` decoration	`Component` decoration	32-bit components consumed
R64	i	scalar	i	0 or unspecified	(x, y, -, -)
R64G64	i	scalar	i	0 or unspecified	(x, y, o, o)
		scalar	i	2	(o, o, z, w)
		two-component vector	i	0 or unspecified	(x, y, z, w)
R64G64B64	i, i+1	scalar	i	0 or unspecified	(x, y, o, o), (o, o, -, -)
		scalar	i	2	(o, o, z, w), (o, o, -, -)
		scalar	i+1	0 or unspecified	(o, o, o, o), (x, y, -, -)
		two-component vector	i	0 or unspecified	(x, y, z, w), (o, o, -, -)
		three-component vector	i	unspecified	(x, y, z, w), (x, y, -, -)
R64G64B64A64	i, i+1	scalar	i	0 or unspecified	(x, y, o, o), (o, o, o, o)
		scalar	i	2	(o, o, z, w), (o, o, o, o)
		scalar	i+1	0 or unspecified	(o, o, o, o), (x, y, o, o)
		scalar	i+1	2	(o, o, o, o), (o, o, z, w)
		two-component vector	i	0 or unspecified	(x, y, z, w), (o, o, o, o)
		two-component vector	i+1	0 or unspecified	(o, o, o, o), (x, y, z, w)
		three-component vector	i	unspecified	(x, y, z, w), (x, y, o, o)
		four-component vector	i	unspecified	(x, y, z, w), (x, y, z, w)

Components indicated by “o” are available for use by other input variables which are sourced from the same attribute. Components indicated by “-” are not available for input variables as there are no default values provided for 64-bit data types, and there is no data provided by the input format.

When a vertex shader input variable declared using a 64-bit floating-point matrix type is assigned a location i, its values are taken from consecutive input attribute locations. Such matrices are treated as an array of column vectors with values taken from the input attributes as shown in Input attribute locations and components accessed by 64-bit input variables. Each column vector starts at the location immediately following the last location of the previous column vector. The number of attributes and components assigned to each matrix is determined by the matrix dimensions and ranges from two to eight locations.

When a vertex shader input variable declared using an array type is assigned a location, its values are taken from consecutive input attributes starting with the corresponding VkVertexInputAttributeDescription::location. The number of attributes and components assigned to each element are determined according to the data type of the array elements and Component decoration (if any) specified in the declaration of the array, as described above. Each element of the array, in order, is assigned to consecutive locations, but all at the same specified component within each location.

Only input variables declared with the data types and component decorations as specified above are supported. Location aliasing is causing two variables to have the same location number. Component aliasing is assigning the same (or overlapping) component number for two location aliases. Location aliasing is allowed only if it does not cause component aliasing. Further, when location aliasing, the aliases sharing the location must all have the same SPIR-V floating-point component type or all have the same width integer-type components.

21.2. Vertex Input Description

Applications specify vertex input attribute and vertex input binding descriptions as part of graphics pipeline creation. VkGraphicsPipelineCreateInfo::pVertexInputState is a pointer to a VkPipelineVertexInputStateCreateInfo value.

The VkPipelineVertexInputStateCreateInfo structure is defined as:

typedef struct VkPipelineVertexInputStateCreateInfo {
    VkStructureType                             sType;
    const void*                                 pNext;
    VkPipelineVertexInputStateCreateFlags       flags;
    uint32_t                                    vertexBindingDescriptionCount;
    const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
    uint32_t                                    vertexAttributeDescriptionCount;
    const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
} VkPipelineVertexInputStateCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
vertexBindingDescriptionCount is the number of vertex binding descriptions provided in pVertexBindingDescriptions.
pVertexBindingDescriptions is a pointer to an array of VkVertexInputBindingDescription structures.
vertexAttributeDescriptionCount is the number of vertex attribute descriptions provided in pVertexAttributeDescriptions.
pVertexAttributeDescriptions is a pointer to an array of VkVertexInputAttributeDescription structures.

Valid Usage

VUID-VkPipelineVertexInputStateCreateInfo-vertexBindingDescriptionCount-00613
vertexBindingDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings
VUID-VkPipelineVertexInputStateCreateInfo-vertexAttributeDescriptionCount-00614
vertexAttributeDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributes
VUID-VkPipelineVertexInputStateCreateInfo-binding-00615
For every binding specified by each element of pVertexAttributeDescriptions, a VkVertexInputBindingDescription must exist in pVertexBindingDescriptions with the same value of binding
VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-00616
All elements of pVertexBindingDescriptions must describe distinct binding numbers
VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-00617
All elements of pVertexAttributeDescriptions must describe distinct attribute locations

Valid Usage (Implicit)

VUID-VkPipelineVertexInputStateCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
VUID-VkPipelineVertexInputStateCreateInfo-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkPipelineVertexInputDivisorStateCreateInfoEXT
VUID-VkPipelineVertexInputStateCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkPipelineVertexInputStateCreateInfo-flags-zerobitmask
flags must be 0
VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-parameter
If vertexBindingDescriptionCount is not 0, pVertexBindingDescriptions must be a valid pointer to an array of vertexBindingDescriptionCount valid VkVertexInputBindingDescription structures
VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-parameter
If vertexAttributeDescriptionCount is not 0, pVertexAttributeDescriptions must be a valid pointer to an array of vertexAttributeDescriptionCount valid VkVertexInputAttributeDescription structures

typedef VkFlags VkPipelineVertexInputStateCreateFlags;

VkPipelineVertexInputStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

Each vertex input binding is specified by the VkVertexInputBindingDescription structure, defined as:

typedef struct VkVertexInputBindingDescription {
    uint32_t             binding;
    uint32_t             stride;
    VkVertexInputRate    inputRate;
} VkVertexInputBindingDescription;

binding is the binding number that this structure describes.
stride is the distance in bytes between two consecutive elements within the buffer.
inputRate is a VkVertexInputRate value specifying whether vertex attribute addressing is a function of the vertex index or of the instance index.

Valid Usage

VUID-VkVertexInputBindingDescription-binding-00618
binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings
VUID-VkVertexInputBindingDescription-stride-00619
stride must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindingStride

Valid Usage (Implicit)

VUID-VkVertexInputBindingDescription-inputRate-parameter
inputRate must be a valid VkVertexInputRate value

Possible values of VkVertexInputBindingDescription::inputRate, specifying the rate at which vertex attributes are pulled from buffers, are:

typedef enum VkVertexInputRate {
    VK_VERTEX_INPUT_RATE_VERTEX = 0,
    VK_VERTEX_INPUT_RATE_INSTANCE = 1,
    VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
} VkVertexInputRate;

VK_VERTEX_INPUT_RATE_VERTEX specifies that vertex attribute addressing is a function of the vertex index.
VK_VERTEX_INPUT_RATE_INSTANCE specifies that vertex attribute addressing is a function of the instance index.

Each vertex input attribute is specified by the VkVertexInputAttributeDescription structure, defined as:

typedef struct VkVertexInputAttributeDescription {
    uint32_t    location;
    uint32_t    binding;
    VkFormat    format;
    uint32_t    offset;
} VkVertexInputAttributeDescription;

location is the shader binding location number for this attribute.
binding is the binding number which this attribute takes its data from.
format is the size and type of the vertex attribute data.
offset is a byte offset of this attribute relative to the start of an element in the vertex input binding.

Valid Usage

VUID-VkVertexInputAttributeDescription-location-00620
location must be less than VkPhysicalDeviceLimits::maxVertexInputAttributes
VUID-VkVertexInputAttributeDescription-binding-00621
binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings
VUID-VkVertexInputAttributeDescription-offset-00622
offset must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributeOffset
VUID-VkVertexInputAttributeDescription-format-00623
format must be allowed as a vertex buffer format, as specified by the VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties

Valid Usage (Implicit)

VUID-VkVertexInputAttributeDescription-format-parameter
format must be a valid VkFormat value

To bind vertex buffers to a command buffer for use in subsequent draw commands, call:

void vkCmdBindVertexBuffers(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    firstBinding,
    uint32_t                                    bindingCount,
    const VkBuffer*                             pBuffers,
    const VkDeviceSize*                         pOffsets);

commandBuffer is the command buffer into which the command is recorded.
firstBinding is the index of the first vertex input binding whose state is updated by the command.
bindingCount is the number of vertex input bindings whose state is updated by the command.
pBuffers is a pointer to an array of buffer handles.
pOffsets is a pointer to an array of buffer offsets.

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.

Valid Usage

VUID-vkCmdBindVertexBuffers-firstBinding-00624
firstBinding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings
VUID-vkCmdBindVertexBuffers-firstBinding-00625
The sum of firstBinding and bindingCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings
VUID-vkCmdBindVertexBuffers-pOffsets-00626
All elements of pOffsets must be less than the size of the corresponding element in pBuffers
VUID-vkCmdBindVertexBuffers-pBuffers-00627
All elements of pBuffers must have been created with the VK_BUFFER_USAGE_VERTEX_BUFFER_BIT flag
VUID-vkCmdBindVertexBuffers-pBuffers-00628
Each element of pBuffers that is non-sparse must be bound completely and contiguously to a single VkDeviceMemory object

Valid Usage (Implicit)

VUID-vkCmdBindVertexBuffers-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdBindVertexBuffers-pBuffers-parameter
pBuffers must be a valid pointer to an array of bindingCount valid VkBuffer handles
VUID-vkCmdBindVertexBuffers-pOffsets-parameter
pOffsets must be a valid pointer to an array of bindingCount VkDeviceSize values
VUID-vkCmdBindVertexBuffers-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdBindVertexBuffers-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdBindVertexBuffers-bindingCount-arraylength
bindingCount must be greater than 0
VUID-vkCmdBindVertexBuffers-commonparent
Both of commandBuffer, and the elements of pBuffers must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

21.3. Vertex Attribute Divisor in Instanced Rendering

If vertexAttributeInstanceRateDivisor feature is enabled and the pNext chain of VkPipelineVertexInputStateCreateInfo includes a VkPipelineVertexInputDivisorStateCreateInfoEXT structure, then that structure controls how vertex attributes are assigned to an instance when instanced rendering is enabled.

The VkPipelineVertexInputDivisorStateCreateInfoEXT structure is defined as:

typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT {
    VkStructureType                                     sType;
    const void*                                         pNext;
    uint32_t                                            vertexBindingDivisorCount;
    const VkVertexInputBindingDivisorDescriptionEXT*    pVertexBindingDivisors;
} VkPipelineVertexInputDivisorStateCreateInfoEXT;

sType is the type of this structure
pNext is NULL or a pointer to an extension-specific structure
vertexBindingDivisorCount is the number of elements in the pVertexBindingDivisors array.
pVertexBindingDivisors is a pointer to an array of VkVertexInputBindingDivisorDescriptionEXT structures, which specifies the divisor value for each binding.

Valid Usage (Implicit)

VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT
VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-pVertexBindingDivisors-parameter
pVertexBindingDivisors must be a valid pointer to an array of vertexBindingDivisorCount VkVertexInputBindingDivisorDescriptionEXT structures
VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-vertexBindingDivisorCount-arraylength
vertexBindingDivisorCount must be greater than 0

The individual divisor values per binding are specified using the VkVertexInputBindingDivisorDescriptionEXT structure which is defined as:

typedef struct VkVertexInputBindingDivisorDescriptionEXT {
    uint32_t    binding;
    uint32_t    divisor;
} VkVertexInputBindingDivisorDescriptionEXT;

binding is the binding number for which the divisor is specified.
divisor is the number of successive instances that will use the same value of the vertex attribute when instanced rendering is enabled. For example, if the divisor is N, the same vertex attribute will be applied to N successive instances before moving on to the next vertex attribute. The maximum value of divisor is implementation dependent and can be queried using VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::maxVertexAttribDivisor. A value of 0 can be used for the divisor if the vertexAttributeInstanceRateZeroDivisor feature is enabled. In this case, the same vertex attribute will be applied to all instances.

If this structure is not used to define a divisor value for an attribute then the divisor has a logical default value of 1.

Valid Usage

VUID-VkVertexInputBindingDivisorDescriptionEXT-binding-01869
binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings
VUID-VkVertexInputBindingDivisorDescriptionEXT-vertexAttributeInstanceRateZeroDivisor-02228
If the vertexAttributeInstanceRateZeroDivisor feature is not enabled, divisor must not be 0
VUID-VkVertexInputBindingDivisorDescriptionEXT-vertexAttributeInstanceRateDivisor-02229
If the vertexAttributeInstanceRateDivisor feature is not enabled, divisor must be 1
VUID-VkVertexInputBindingDivisorDescriptionEXT-divisor-01870
divisor must be a value between 0 and VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::maxVertexAttribDivisor, inclusive.
VUID-VkVertexInputBindingDivisorDescriptionEXT-inputRate-01871
VkVertexInputBindingDescription::inputRate must be of type VK_VERTEX_INPUT_RATE_INSTANCE for this binding.

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 vkCmdDraw, or a value taken from the index buffer for vkCmdDrawIndexed), and let instanceIndex be the instance number of the draw (a value between firstInstance and firstInstance+instanceCount).
Let divisor be the member of VkPipelineVertexInputDivisorStateCreateInfoEXT::pVertexBindingDivisors with VkVertexInputBindingDivisorDescriptionEXT::binding equal to attribDesc.binding.

bufferBindingAddress = buffer[binding].baseAddress + offset[binding];

if (bindingDesc.inputRate == VK_VERTEX_INPUT_RATE_VERTEX)
    vertexOffset = vertexIndex * bindingDesc.stride;
else
    if (divisor == 0)
        vertexOffset = firstInstance * bindingDesc.stride;
    else
        vertexOffset = (firstInstance + ((instanceIndex - firstInstance) / divisor)) * 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 as described in Packed Formats. Otherwise, attribAddress must be a multiple of the size in bytes of the component type indicated by format (see Formats). 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.

21.4. Example

To create a graphics pipeline that uses the following vertex description:

struct Vertex
{
    float   x, y, z, w;
    uint8_t u, v;
};

The application could use the following set of structures:

const VkVertexInputBindingDescription binding =
{
    0,                                          // binding
    sizeof(Vertex),                             // stride
    VK_VERTEX_INPUT_RATE_VERTEX                 // inputRate
};

const VkVertexInputAttributeDescription attributes[] =
{
    {
        0,                                      // location
        binding.binding,                        // binding
        VK_FORMAT_R32G32B32A32_SFLOAT,          // format
        0                                       // offset
    },
    {
        1,                                      // location
        binding.binding,                        // binding
        VK_FORMAT_R8G8_UNORM,                   // format
        4 * sizeof(float)                       // offset
    }
};

const VkPipelineVertexInputStateCreateInfo viInfo =
{
    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO,    // sType
    NULL,                         // pNext
    0,                            // flags
    1,                            // vertexBindingDescriptionCount
    &binding,                     // pVertexBindingDescriptions
    2,                            // vertexAttributeDescriptionCount
    &attributes[0]                // pVertexAttributeDescriptions
};

22. Tessellation

Tessellation involves three pipeline stages. First, a tessellation control shader transforms control points of a patch and can produce per-patch data. Second, a fixed-function tessellator generates multiple primitives corresponding to a tessellation of the patch in (u,v) or (u,v,w) parameter space. Third, a tessellation evaluation shader transforms the vertices of the tessellated patch, for example to compute their positions and attributes as part of the tessellated surface. The tessellator is enabled when the pipeline contains both a tessellation control shader and a tessellation evaluation shader.

22.1. Tessellator

If a pipeline includes both tessellation shaders (control and evaluation), the tessellator consumes each input patch (after vertex shading) and produces a new set of independent primitives (points, lines, or triangles). These primitives are logically produced by subdividing a geometric primitive (rectangle or triangle) according to the per-patch outer and inner tessellation levels written by the tessellation control shader. These levels are specified using the built-in variables TessLevelOuter and TessLevelInner, respectively. This subdivision is performed in an implementation-dependent manner. If no tessellation shaders are present in the pipeline, the tessellator is disabled and incoming primitives are passed through without modification.

The type of subdivision performed by the tessellator is specified by an OpExecutionMode instruction in the tessellation evaluation or tessellation control shader using one of execution modes Triangles, Quads, and IsoLines. Other tessellation-related execution modes can also be specified in either the tessellation control or tessellation evaluation shaders, and if they are specified in both then the modes must be the same.

Tessellation execution modes include:

Triangles, Quads, and IsoLines. These control the type of subdivision and topology of the output primitives. One mode must be set in at least one of the tessellation shader stages.
VertexOrderCw and VertexOrderCcw. These control the orientation of triangles generated by the tessellator. One mode must be set in at least one of the tessellation shader stages.
PointMode. Controls generation of points rather than triangles or lines. This functionality defaults to disabled, and is enabled if either shader stage includes the execution mode.
SpacingEqual, SpacingFractionalEven, and SpacingFractionalOdd. Controls the spacing of segments on the edges of tessellated primitives. One mode must be set in at least one of the tessellation shader stages.
OutputVertices. Controls the size of the output patch of the tessellation control shader. One value must be set in at least one of the tessellation shader stages.

For triangles, the tessellator subdivides a triangle primitive into smaller triangles. For quads, the tessellator subdivides a rectangle primitive into smaller triangles. For isolines, the tessellator subdivides a rectangle primitive into a collection of line segments arranged in strips stretching across the rectangle in the u dimension (i.e. the coordinates in TessCoord are of the form (0,x) through (1,x) for all tessellation evaluation shader invocations that share a line).

Each vertex produced by the tessellator has an associated (u,v,w) or (u,v) position in a normalized parameter space, with parameter values in the range [0,1], as illustrated in figures Domain parameterization for tessellation primitive modes (upper-left origin) and Domain parameterization for tessellation primitive modes (lower-left origin). The domain space can have either an upper-left or lower-left origin, selected by the domainOrigin member of VkPipelineTessellationDomainOriginStateCreateInfo.

Figure 12. Domain parameterization for tessellation primitive modes (upper-left origin)

Figure 13. Domain parameterization for tessellation primitive modes (lower-left origin)

Caption

In the domain parameterization diagrams, the coordinates illustrate the value of TessCoord at the corners of the domain. The labels on the edges indicate the inner (IL0 and IL1) and outer (OL0 through OL3) tessellation level values used to control the number of subdivisions along each edge of the domain.

For triangles, the vertex’s position is a barycentric coordinate (u,v,w), where u + v + w = 1.0, and indicates the relative influence of the three vertices of the triangle on the position of the vertex. For quads and isolines, the position is a (u,v) coordinate indicating the relative horizontal and vertical position of the vertex relative to the subdivided rectangle. The subdivision process is explained in more detail in subsequent sections.

22.2. Tessellator Patch Discard

A patch is discarded by the tessellator if any relevant outer tessellation level is less than or equal to zero.

Patches will also be discarded if any relevant outer tessellation level corresponds to a floating-point NaN (not a number) in implementations supporting NaN.

No new primitives are generated and the tessellation evaluation shader is not executed for patches that are discarded. For Quads, all four outer levels are relevant. For Triangles and IsoLines, only the first three or two outer levels, respectively, are relevant. Negative inner levels will not cause a patch to be discarded; they will be clamped as described below.

22.3. Tessellator Spacing

Each of the tessellation levels is used to determine the number and spacing of segments used to subdivide a corresponding edge. The method used to derive the number and spacing of segments is specified by an OpExecutionMode in the tessellation control or tessellation evaluation shader using one of the identifiers SpacingEqual, SpacingFractionalEven, or SpacingFractionalOdd.

If SpacingEqual is used, the floating-point tessellation level is first clamped to [1, maxLevel], where maxLevel is the implementation-dependent maximum tessellation level (VkPhysicalDeviceLimits::maxTessellationGenerationLevel). The result is rounded up to the nearest integer n, and the corresponding edge is divided into n segments of equal length in (u,v) space.

If SpacingFractionalEven is used, the tessellation level is first clamped to [2, maxLevel] and then rounded up to the nearest even integer n. If SpacingFractionalOdd is used, the tessellation level is clamped to [1, maxLevel - 1] and then rounded up to the nearest odd integer n. If n is one, the edge will not be subdivided. Otherwise, the corresponding edge will be divided into n - 2 segments of equal length, and two additional segments of equal length that are typically shorter than the other segments. The length of the two additional segments relative to the others will decrease monotonically with n - f, where f is the clamped floating-point tessellation level. When n - f is zero, the additional segments will have equal length to the other segments. As n - f approaches 2.0, the relative length of the additional segments approaches zero. The two additional segments must be placed symmetrically on opposite sides of the subdivided edge. The relative location of these two segments is implementation-dependent, but must be identical for any pair of subdivided edges with identical values of f.

When tessellating triangles or quads using point mode with fractional odd spacing, the tessellator may produce interior vertices that are positioned on the edge of the patch if an inner tessellation level is less than or equal to one. Such vertices are considered distinct from vertices produced by subdividing the outer edge of the patch, even if there are pairs of vertices with identical coordinates.

22.4. Tessellation Primitive Ordering

Few guarantees are provided for the relative ordering of primitives produced by tessellation, as they pertain to primitive order.

The output primitives generated from each input primitive are passed to subsequent pipeline stages in an implementation-dependent order.
All output primitives generated from a given input primitive are passed to subsequent pipeline stages before any output primitives generated from subsequent input primitives.

22.5. Tessellator Vertex Winding Order

When the tessellator produces triangles (in the Triangles or Quads modes), the orientation of all triangles is specified with an OpExecutionMode of VertexOrderCw or VertexOrderCcw in the tessellation control or tessellation evaluation shaders. If the order is VertexOrderCw, the vertices of all generated triangles will have clockwise ordering in (u,v) or (u,v,w) space. If the order is VertexOrderCcw, the vertices will have counter-clockwise ordering in that space.

If the tessellation domain has an upper-left origin, the vertices of a triangle have counter-clockwise ordering if

: a = u₀ v₁ - u₁ v₀ + u₁ v₂ - u₂ v₁ + u₂ v₀ - u₀ v₂

is negative, and clockwise ordering if a is positive. u_i and v_i are the u and v coordinates in normalized parameter space of the ith vertex of the triangle. If the tessellation domain has a lower-left origin, the vertices of a triangle have counter-clockwise ordering if a is positive, and clockwise ordering if a is negative.

Note

The value a is proportional (with a positive factor) to the signed area of the triangle.

In Triangles mode, even though the vertex coordinates have a w value, it does not participate directly in the computation of a, being an affine combination of u and v.

22.6. Triangle Tessellation

If the tessellation primitive mode is Triangles, an equilateral triangle is subdivided into a collection of triangles covering the area of the original triangle. First, the original triangle is subdivided into a collection of concentric equilateral triangles. The edges of each of these triangles are subdivided, and the area between each triangle pair is filled by triangles produced by joining the vertices on the subdivided edges. The number of concentric triangles and the number of subdivisions along each triangle except the outermost is derived from the first inner tessellation level. The edges of the outermost triangle are subdivided independently, using the first, second, and third outer tessellation levels to control the number of subdivisions of the u = 0 (left), v = 0 (bottom), and w = 0 (right) edges, respectively. The second inner tessellation level and the fourth outer tessellation level have no effect in this mode.

If the first inner tessellation level and all three outer tessellation levels are exactly one after clamping and rounding, only a single triangle with (u,v,w) coordinates of (0,0,1), (1,0,0), and (0,1,0) is generated. If the inner tessellation level is one and any of the outer tessellation levels is greater than one, the inner tessellation level is treated as though it were originally specified as 1 + ε and will result in a two- or three-segment subdivision depending on the tessellation spacing. When used with fractional odd spacing, the three-segment subdivision may produce inner vertices positioned on the edge of the triangle.

If any tessellation level is greater than one, tessellation begins by producing a set of concentric inner triangles and subdividing their edges. First, the three outer edges are temporarily subdivided using the clamped and rounded first inner tessellation level and the specified tessellation spacing, generating n segments. For the outermost inner triangle, the inner triangle is degenerate — a single point at the center of the triangle — if n is two. Otherwise, for each corner of the outer triangle, an inner triangle corner is produced at the intersection of two lines extended perpendicular to the corner’s two adjacent edges running through the vertex of the subdivided outer edge nearest that corner. If n is three, the edges of the inner triangle are not subdivided and is the final triangle in the set of concentric triangles. Otherwise, each edge of the inner triangle is divided into n - 2 segments, with the n - 1 vertices of this subdivision produced by intersecting the inner edge with lines perpendicular to the edge running through the n - 1 innermost vertices of the subdivision of the outer edge. Once the outermost inner triangle is subdivided, the previous subdivision process repeats itself, using the generated triangle as an outer triangle. This subdivision process is illustrated in Inner Triangle Tessellation.

Figure 14. Inner Triangle Tessellation

Caption

In the Inner Triangle Tessellation diagram, inner tessellation levels of (a) five and (b) four are shown (not to scale). Solid black circles depict vertices along the edges of the concentric triangles. The edges of inner triangles are subdivided by intersecting the edge with segments perpendicular to the edge passing through each inner vertex of the subdivided outer edge. Dotted lines depict edges connecting corresponding vertices on the inner and outer triangle edges.

Once all the concentric triangles are produced and their edges are subdivided, the area between each pair of adjacent inner triangles is filled completely with a set of non-overlapping triangles. In this subdivision, two of the three vertices of each triangle are taken from adjacent vertices on a subdivided edge of one triangle; the third is one of the vertices on the corresponding edge of the other triangle. If the innermost triangle is degenerate (i.e., a point), the triangle containing it is subdivided into six triangles by connecting each of the six vertices on that triangle with the center point. If the innermost triangle is not degenerate, that triangle is added to the set of generated triangles as-is.

After the area corresponding to any inner triangles is filled, the tessellator generates triangles to cover the area between the outermost triangle and the outermost inner triangle. To do this, the temporary subdivision of the outer triangle edge above is discarded. Instead, the u = 0, v = 0, and w = 0 edges are subdivided according to the first, second, and third outer tessellation levels, respectively, and the tessellation spacing. The original subdivision of the first inner triangle is retained. The area between the outer and first inner triangles is completely filled by non-overlapping triangles as described above. If the first (and only) inner triangle is degenerate, a set of triangles is produced by connecting each vertex on the outer triangle edges with the center point.

After all triangles are generated, each vertex in the subdivided triangle is assigned a barycentric (u,v,w) coordinate based on its location relative to the three vertices of the outer triangle.

The algorithm used to subdivide the triangular domain in (u,v,w) space into individual triangles is implementation-dependent. However, the set of triangles produced will completely cover the domain, and no portion of the domain will be covered by multiple triangles.

Output triangles are generated with a topology similar to triangle lists, except that the order in which each triangle is generated, and the order in which the vertices are generated for each triangle, are implementation-dependent. However, the order of vertices in each triangle is consistent across the domain as described in Tessellator Vertex Winding Order.

22.7. Quad Tessellation

If the tessellation primitive mode is Quads, a rectangle is subdivided into a collection of triangles covering the area of the original rectangle. First, the original rectangle is subdivided into a regular mesh of rectangles, where the number of rectangles along the u = 0 and u = 1 (vertical) and v = 0 and v = 1 (horizontal) edges are derived from the first and second inner tessellation levels, respectively. All rectangles, except those adjacent to one of the outer rectangle edges, are decomposed into triangle pairs. The outermost rectangle edges are subdivided independently, using the first, second, third, and fourth outer tessellation levels to control the number of subdivisions of the u = 0 (left), v = 0 (bottom), u = 1 (right), and v = 1 (top) edges, respectively. The area between the inner rectangles of the mesh and the outer rectangle edges are filled by triangles produced by joining the vertices on the subdivided outer edges to the vertices on the edge of the inner rectangle mesh.

If both clamped inner tessellation levels and all four clamped outer tessellation levels are exactly one, only a single triangle pair covering the outer rectangle is generated. Otherwise, if either clamped inner tessellation level is one, that tessellation level is treated as though it were originally specified as 1 + ε and will result in a two- or three-segment subdivision depending on the tessellation spacing. When used with fractional odd spacing, the three-segment subdivision may produce inner vertices positioned on the edge of the rectangle.

If any tessellation level is greater than one, tessellation begins by subdividing the u = 0 and u = 1 edges of the outer rectangle into m segments using the clamped and rounded first inner tessellation level and the tessellation spacing. The v = 0 and v = 1 edges are subdivided into n segments using the second inner tessellation level. Each vertex on the u = 0 and v = 0 edges are joined with the corresponding vertex on the u = 1 and v = 1 edges to produce a set of vertical and horizontal lines that divide the rectangle into a grid of smaller rectangles. The primitive generator emits a pair of non-overlapping triangles covering each such rectangle not adjacent to an edge of the outer rectangle. The boundary of the region covered by these triangles forms an inner rectangle, the edges of which are subdivided by the grid vertices that lie on the edge. If either m or n is two, the inner rectangle is degenerate, and one or both of the rectangle’s edges consist of a single point. This subdivision is illustrated in Figure Inner Quad Tessellation.

Figure 15. Inner Quad Tessellation

Caption

In the Inner Quad Tessellation diagram, inner quad tessellation levels of (a) (4,2) and (b) (7,4) are shown. The regions highlighted in red in figure (b) depict the 10 inner rectangles, each of which will be subdivided into two triangles. Solid black circles depict vertices on the boundary of the outer and inner rectangles, where the inner rectangle on the top figure is degenerate (a single line segment). Dotted lines depict the horizontal and vertical edges connecting corresponding vertices on the inner and outer rectangle edges.

After the area corresponding to the inner rectangle is filled, the tessellator must produce triangles to cover the area between the inner and outer rectangles. To do this, the subdivision of the outer rectangle edge above is discarded. Instead, the u = 0, v = 0, u = 1, and v = 1 edges are subdivided according to the first, second, third, and fourth outer tessellation levels, respectively, and the tessellation spacing. The original subdivision of the inner rectangle is retained. The area between the outer and inner rectangles is completely filled by non-overlapping triangles. Two of the three vertices of each triangle are adjacent vertices on a subdivided edge of one rectangle; the third is one of the vertices on the corresponding edge of the other rectangle. If either edge of the innermost rectangle is degenerate, the area near the corresponding outer edges is filled by connecting each vertex on the outer edge with the single vertex making up the inner edge.

The algorithm used to subdivide the rectangular domain in (u,v) space into individual triangles is implementation-dependent. However, the set of triangles produced will completely cover the domain, and no portion of the domain will be covered by multiple triangles.

22.8. Isoline Tessellation

If the tessellation primitive mode is IsoLines, a set of independent horizontal line segments is drawn. The segments are arranged into connected strips called isolines, where the vertices of each isoline have a constant v coordinate and u coordinates covering the full range [0,1]. The number of isolines generated is derived from the first outer tessellation level; the number of segments in each isoline is derived from the second outer tessellation level. Both inner tessellation levels and the third and fourth outer tessellation levels have no effect in this mode.

As with quad tessellation above, isoline tessellation begins with a rectangle. The u = 0 and u = 1 edges of the rectangle are subdivided according to the first outer tessellation level. For the purposes of this subdivision, the tessellation spacing mode is ignored and treated as equal_spacing. An isoline is drawn connecting each vertex on the u = 0 rectangle edge to the corresponding vertex on the u = 1 rectangle edge, except that no line is drawn between (0,1) and (1,1). If the number of isolines on the subdivided u = 0 and u = 1 edges is n, this process will result in n equally spaced lines with constant v coordinates of 0, \(\frac{1}{n}, \frac{2}{n}, \ldots, \frac{n-1}{n}\).

Each of the n isolines is then subdivided according to the second outer tessellation level and the tessellation spacing, resulting in m line segments. Each segment of each line is emitted by the tessellator. These line segments are generated with a topology similar to line lists, except that the order in which each line is generated, and the order in which the vertices are generated for each line segment, are implementation-dependent.

22.9. Tessellation Point Mode

For all primitive modes, the tessellator is capable of generating points instead of lines or triangles. If the tessellation control or tessellation evaluation shader specifies the OpExecutionMode PointMode, the primitive generator will generate one point for each distinct vertex produced by tessellation, rather than emitting triangles or lines. Otherwise, the tessellator will produce a collection of line segments or triangles according to the primitive mode. These points are generated with a topology similar to point lists, except the order in which the points are generated for each input primitive is undefined.

22.10. Tessellation Pipeline State

The pTessellationState member of VkGraphicsPipelineCreateInfo is a pointer to a VkPipelineTessellationStateCreateInfo structure.

The VkPipelineTessellationStateCreateInfo structure is defined as:

typedef struct VkPipelineTessellationStateCreateInfo {
    VkStructureType                           sType;
    const void*                               pNext;
    VkPipelineTessellationStateCreateFlags    flags;
    uint32_t                                  patchControlPoints;
} VkPipelineTessellationStateCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
patchControlPoints number of control points per patch.

Valid Usage

VUID-VkPipelineTessellationStateCreateInfo-patchControlPoints-01214
patchControlPoints must be greater than zero and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize

Valid Usage (Implicit)

VUID-VkPipelineTessellationStateCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO
VUID-VkPipelineTessellationStateCreateInfo-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkPipelineTessellationDomainOriginStateCreateInfo
VUID-VkPipelineTessellationStateCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkPipelineTessellationStateCreateInfo-flags-zerobitmask
flags must be 0

typedef VkFlags VkPipelineTessellationStateCreateFlags;

VkPipelineTessellationStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

The VkPipelineTessellationDomainOriginStateCreateInfo structure is defined as:

typedef struct VkPipelineTessellationDomainOriginStateCreateInfo {
    VkStructureType               sType;
    const void*                   pNext;
    VkTessellationDomainOrigin    domainOrigin;
} VkPipelineTessellationDomainOriginStateCreateInfo;

or the equivalent

typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
domainOrigin is a VkTessellationDomainOrigin value controlling the origin of the tessellation domain space.

If the VkPipelineTessellationDomainOriginStateCreateInfo structure is included in the pNext chain of VkPipelineTessellationStateCreateInfo, it controls the origin of the tessellation domain. If this structure is not present, it is as if domainOrigin were VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT.

Valid Usage (Implicit)

VUID-VkPipelineTessellationDomainOriginStateCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO
VUID-VkPipelineTessellationDomainOriginStateCreateInfo-domainOrigin-parameter
domainOrigin must be a valid VkTessellationDomainOrigin value

The possible tessellation domain origins are specified by the VkTessellationDomainOrigin enumeration:

typedef enum VkTessellationDomainOrigin {
    VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0,
    VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1,
    VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
    VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT,
    VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF
} VkTessellationDomainOrigin;

or the equivalent

typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR;

VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT specifies that the origin of the domain space is in the upper left corner, as shown in figure Domain parameterization for tessellation primitive modes (upper-left origin).
VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT specifies that the origin of the domain space is in the lower left corner, as shown in figure Domain parameterization for tessellation primitive modes (lower-left origin).

This enum affects how the VertexOrderCw and VertexOrderCcw tessellation execution modes are interpreted, since the winding is defined relative to the orientation of the domain.

23. Geometry Shading

23.1. Geometry Shader Input Primitives

Each geometry shader invocation has access to all vertices in the primitive (and their associated data), which are presented to the shader as an array of inputs.

The input primitive type expected by the geometry shader is specified with an OpExecutionMode instruction in the geometry shader, and must match the incoming primitive type specified by either the pipeline’s primitive topology if tessellation is inactive, or the tessellation mode if tessellation is active, as follows:

An input primitive type of InputPoints must only be used with a pipeline topology of VK_PRIMITIVE_TOPOLOGY_POINT_LIST, or with a tessellation shader that specifies PointMode. The input arrays always contain one element, as described by the point list topology or tessellation in point mode.
An input primitive type of InputLines must only be used with a pipeline topology of VK_PRIMITIVE_TOPOLOGY_LINE_LIST or VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, or with a tessellation shader specifying IsoLines that does not specify PointMode. The input arrays always contain two elements, as described by the line list topology or line strip topology, or by isoline tessellation.
An input primitive type of InputLinesAdjacency must only be used when tessellation is inactive, with a pipeline topology of VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY or VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY. The input arrays always contain four elements, as described by the line list with adjacency topology or line strip with adjacency topology.
An input primitive type of Triangles must only be used with a pipeline topology of VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN; or with a tessellation shader specifying Quads or Triangles that does not specify PointMode. The input arrays always contain three elements, as described by the triangle list topology, triangle strip topology, or triangle fan topology, or by triangle or quad tessellation. Vertices may be in a different absolute order to that specified by the topology, but must adhere to the specified winding order.
An input primitive type of InputTrianglesAdjacency must only be used when tessellation is inactive, with a pipeline topology of VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY. The input arrays always contain six elements, as described by the triangle list with adjacency topology or triangle strip with adjacency topology. Vertices may be in a different absolute order to that specified by the topology, but must adhere to the specified winding order, and the vertices making up the main primitive must still occur at the first, third, and fifth index.

23.2. Geometry Shader Output Primitives

A geometry shader generates primitives in one of three output modes: points, line strips, or triangle strips. The primitive mode is specified in the shader using an OpExecutionMode instruction with the OutputPoints, OutputLineStrip or OutputTriangleStrip modes, respectively. Each geometry shader must include exactly one output primitive mode.

The vertices output by the geometry shader are assembled into points, lines, or triangles based on the output primitive type and the resulting primitives are then further processed as described in Rasterization. If the number of vertices emitted by the geometry shader is not sufficient to produce a single primitive, vertices corresponding to incomplete primitives are not processed by subsequent pipeline stages. The number of vertices output by the geometry shader is limited to a maximum count specified in the shader.

The maximum output vertex count is specified in the shader using an OpExecutionMode instruction with the mode set to OutputVertices and the maximum number of vertices that will be produced by the geometry shader specified as a literal. Each geometry shader must specify a maximum output vertex count.

23.3. Multiple Invocations of Geometry Shaders

Geometry shaders can be invoked more than one time for each input primitive. This is known as geometry shader instancing and is requested by including an OpExecutionMode instruction with mode specified as Invocations and the number of invocations specified as an integer literal.

In this mode, the geometry shader will execute at least n times for each input primitive, where n is the number of invocations specified in the OpExecutionMode instruction. The instance number is available to each invocation as a built-in input using InvocationId.

23.4. Geometry Shader Primitive Ordering

Limited guarantees are provided for the relative ordering of primitives produced by a geometry shader, as they pertain to primitive order.

For instanced geometry shaders, the output primitives generated from each input primitive are passed to subsequent pipeline stages using the invocation number to order the primitives, from least to greatest.
All output primitives generated from a given input primitive are passed to subsequent pipeline stages before any output primitives generated from subsequent input primitives.

23.5. Geometry Shader Passthrough

A geometry shader that uses the PassthroughNV decoration on a variable in its input interface is considered a passthrough geometry shader. Output primitives in a passthrough geometry shader must have the same topology as the input primitive and are not produced by emitting vertices. The vertices of the output primitive have two different types of attributes, per-vertex and per-primitive. Geometry shader input variables with PassthroughNV decoration are considered to produce per-vertex outputs, where values for each output vertex are copied from the corresponding input vertex. Any built-in or user-defined geometry shader outputs are considered per-primitive in a passthrough geometry shader, where a single output value is copied to all output vertices.

The remainder of this section details the usage of the PassthroughNV decoration and modifications to the interface matching rules when using passthrough geometry shaders.

23.5.1. `PassthroughNV` Decoration

Decorating a geometry shader input variable with the PassthroughNV decoration indicates that values of this input are copied through to the corresponding vertex of the output primitive. Input variables and block members which do not have the PassthroughNV decoration are consumed by the geometry shader without being passed through to subsequent stages.

The PassthroughNV decoration must only be used within a geometry shader.

Any variable decorated with PassthroughNV must be declared using the Input storage class.

The PassthroughNV decoration must not be used with any of:

an input primitive type other than InputPoints, InputLines, or Triangles, as specified by the mode for OpExecutionMode.
an invocation count other than one, as specified by the Invocations mode for OpExecutionMode.
an OpEntryPoint which statically uses the OpEmitVertex or OpEndPrimitive instructions.
a variable decorated with the InvocationId built-in decoration.
a variable decorated with the PrimitiveId built-in decoration that is declared using the Input storage class.

23.5.2. Passthrough Interface Matching

When a passthrough geometry shader is in use, the Interface Matching rules involving the geometry shader input and output interfaces operate as described in this section.

For the purposes of matching passthrough geometry shader inputs with outputs of the previous pipeline stages, the PassthroughNV decoration is ignored.

For the purposes of matching the outputs of the geometry shader with subsequent pipeline stages, each input variable with the PassthroughNV decoration is considered to add an equivalent output variable with the same type, decoration (other than PassthroughNV), number, and declaration order on the output interface. The output variable declaration corresponding to an input variable decorated with PassthroughNV will be identical to the input declaration, except that the outermost array dimension of such variables is removed. The output block declaration corresponding to an input block decorated with PassthroughNV or having members decorated with PassthroughNV will be identical to the input declaration, except that the outermost array dimension of such declaration is removed.

If an input block is decorated with PassthroughNV, the equivalent output block contains all the members of the input block. Otherwise, the equivalent output block contains only those input block members decorated with PassthroughNV. All members of the corresponding output block are assigned Location and Component decorations identical to those assigned to the corresponding input block members.

Output variables and blocks generated from inputs decorated with PassthroughNV will only exist for the purposes of interface matching; these declarations are not available to geometry shader code or listed in the module interface.

For the purposes of component counting, passthrough geometry shaders count all statically used input variable components declared with the PassthroughNV decoration as output components as well, since their values will be copied to the output primitive produced by the geometry shader.

24. Mesh Shading

Task and mesh shaders operate in workgroups to produce a collection of primitives that will be processed by subsequent stages of the graphics pipeline.

Work on the mesh pipeline is initiated by the application drawing a set of mesh tasks organized in global workgroups. If the optional task shader is active, each workgroup triggers the execution of task shader invocations that will create a new set of mesh workgroups upon completion. Each of these created workgroups, or each of the original workgroups if no task shader is present, triggers the execution of mesh shader invocations.

Each mesh shader workgroup emits zero or more output primitives along with the group of vertices and their associated data required for each output primitive.

24.1. Task Shader Input

For every workgroup issued via the drawing commands a group of task shader invocations is executed. There are no inputs other than the builtin workgroup identifiers.

24.2. Task Shader Output

The task shader can emit zero or more mesh workgroups to be generated using the built-in variable TaskCountNV. This value must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxTaskOutputCount.

It can also output user-defined data that is passed as input to all mesh shader invocations that the task creates. These outputs are decorated as PerTaskNV.

24.3. Mesh Generation

If a task shader exists, the mesh assembler creates a variable amount of mesh workgroups depending on each task’s output. If there is no task shader, the drawing commands emit the mesh shader invocations directly.

24.4. Mesh Shader Input

The only inputs available to the mesh shader are variables identifying the specific workgroup and invocation and, if applicable, any outputs written as PerTaskNV by the task shader that spawned the mesh shader’s workgroup. The mesh shader can operate without a task shader as well.

24.5. Mesh Shader Output Primitives

A mesh shader generates primitives in one of three output modes: points, lines, or triangles. The primitive mode is specified in the shader using an OpExecutionMode instruction with the OutputPoints, OutputLinesNV, or OutputTrianglesNV modes, respectively. Each mesh shader must include exactly one output primitive mode.

The maximum output vertex count is specified as a literal in the shader using an OpExecutionMode instruction with the mode set to OutputVertices and must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputVertices.

The maximum output primitive count is specified as a literal in the shader using an OpExecutionMode instruction with the mode set to OutputPrimitivesNV and must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputPrimitives.

The number of primitives output by the mesh shader is provided via writing to the built-in variable PrimitiveCountNV and must be less than or equal to the maximum output primitive count specified in the shader. A variable decorated with PrimitiveIndicesNV is an output array of local index values into the vertex output arrays from which primitives are assembled according to the output primitive type. These resulting primitives are then further processed as described in Rasterization.

24.6. Mesh Shader Per-View Outputs

The mesh shader outputs decorated with the PositionPerViewNV, ClipDistancePerViewNV, CullDistancePerViewNV, LayerPerViewNV, and ViewportMaskPerViewNV built-in decorations are the per-view versions of the single-view variables with equivalent names (that is Position, ClipDistance, CullDistance, Layer, and ViewportMaskNV, respectively). If a shader statically assigns a value to any element of a per-view array it must not statically assign a value to the equivalent single-view variable.

Each of these outputs is considered arrayed, with separate values for each view. The view number is used to index the first dimension of these arrays.

The second dimension of the ClipDistancePerViewNV, and CullDistancePerViewNV arrays have the same requirements as the ClipDistance, and CullDistance arrays.

If a mesh shader output is per-view, the corresponding fragment shader input is taken from the element of the per-view output array that corresponds to the view that is currently being processed by the fragment shader.

24.7. Mesh Shader Primitive Ordering

Following guarantees are provided for the relative ordering of primitives produced by a mesh shader, as they pertain to primitive order.

When a task shader is used, mesh workgroups spawned from lower tasks will be ordered prior those workgroups from subsequent tasks.
All output primitives generated from a given mesh workgroup are passed to subsequent pipeline stages before any output primitives generated from subsequent input workgroups.
All output primitives within a mesh workgroup, will be generated in the ordering provided by the builtin primitive indexbuffer (from low address to high address).

25. Fixed-Function Vertex Post-Processing

After programmable vertex processing, the following fixed-function operations are applied to vertices of the resulting primitives:

Transform feedback (see Transform Feedback)
Viewport swizzle (see Viewport Swizzle)
Flat shading (see Flat Shading).
Primitive clipping, including client-defined half-spaces (see Primitive Clipping).
Shader output attribute clipping (see Clipping Shader Outputs).
Clip space W scaling (see Controlling Viewport W Scaling).
Perspective division on clip coordinates (see Coordinate Transformations).
Viewport mapping, including depth range scaling (see Controlling the Viewport).
Front face determination for polygon primitives (see Basic Polygon Rasterization).

editing-note

TODO:Odd that this one link to a different chapter is in this list.

Next, rasterization is performed on primitives as described in chapter Rasterization.

25.1. Transform Feedback

Before any other fixed-function vertex post-processing, vertex outputs from the last shader in the vertex processing stage can be written out to one or more transform feedback buffers bound to the command buffer. To capture vertex outputs the last vertex processing stage shader must be declared with the Xfb execution mode. Outputs decorated with XfbBuffer will be written out to the corresponding transform feedback buffers bound to the command buffer when transform feedback is active. Transform feedback buffers are bound to the command buffer by using vkCmdBindTransformFeedbackBuffersEXT. Transform feedback is made active by calling vkCmdBeginTransformFeedbackEXT and made inactive by calling vkCmdEndTransformFeedbackEXT. After vertex data is written it is possible to use vkCmdDrawIndirectByteCountEXT to start a new draw where the vertexCount is derived from the number of bytes written by a previous transform feedback.

When an individual point, line, or triangle primitive reaches the transform feedback stage while transform feedback is active, the values of the specified output variables are assembled into primitives and appended to the bound transform feedback buffers. After activating transform feedback, the values of the first assembled primitive are written at the starting offsets of the bound transform feedback buffers, and subsequent primitives are appended to the buffer. If the optional pCounterBuffers and pCounterBufferOffsets parameters are specified, the starting points within the transform feedback buffers are adjusted so data is appended to the previously written values indicated by the value stored by the implementation in the counter buffer.

For multi-vertex primitives, all values for a given vertex are written before writing values for any other vertex. Implementations may write out any vertex within the primitive first, but all subsequent vertices for that primitive must be written out in a consistent winding order defined as follows:

If neither geometry or tessellation shading is active, vertices within a primitive are appended according to the winding order described by the primitive topology defined by the VkPipelineInputAssemblyStateCreateInfo:topology used to execute the drawing command.
If geometry shading is active, vertices within a primitive are appended according to the winding order described by the primitive topology defined by the OutputPoints, OutputLineStrips, or OutputTriangleStrips execution mode.
If tessellation shading is active but geometry shading is not, vertices within a primitive are appended according to the winding order defined by triangle tessellation, quad tessellation, and isoline tessellation.

When capturing vertices, the stride associated with each transform feedback buffer, as indicated by the XfbStride decoration, indicates the number of bytes of storage reserved for each vertex in the transform feedback buffer. For every vertex captured, each output attribute with a Offset decoration will be written to the storage reserved for the vertex at the associated transform feedback buffer. When writing output variables that are arrays or structures, individual array elements or structure members are written tightly packed in order. For vector types, individual components are written in order. For matrix types, outputs are written as an array of column vectors.

If any component of an output with an assigned transform feedback offset was not written to by its shader, the value recorded for that component is undefined. All components of an output variable must be written at an offset aligned to the size of the component. The size of each component of an output variable must be at least 32-bits. When capturing a vertex, any portion of the reserved storage not associated with an output variable with an assigned transform feedback offset will be unmodified.

When transform feedback is inactive, no vertices are recorded. If there is a valid counter buffer handle and counter buffer offset in the pCounterBuffers and pCounterBufferOffsets arrays, writes to the corresponding transform feedback buffer will start at the byte offset represented by the value stored in the counter buffer location.

Individual lines or triangles of a strip or fan primitive will be extracted and recorded separately. Incomplete primitives are not recorded.

When using a geometry shader that emits vertices to multiple vertex streams, a primitive will be assembled and output for each stream when there are enough vertices emitted for the output primitive type. All outputs assigned to a given transform feedback buffer are required to come from a single vertex stream.

The sizes of the transform feedback buffers are defined by the vkCmdBindTransformFeedbackBuffersEXT pSizes parameter for each of the bound buffers, or the size of the bound buffer, whichever is the lesser. If there is less space remaining in any of the transform feedback buffers than the size of the all the vertex data for that primitive based on the XfbStride for that XfbBuffer then no vertex data of that primitive is recorded in any transform feedback buffer, and the value for the number of primitives written in the corresponding VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT query for all transform feedback buffers is no longer incremented.

Any outputs made to a XfbBuffer that is not bound to a transform feedback buffer is ignored.

To bind transform feedback buffers to a command buffer for use in subsequent draw commands, call:

void vkCmdBindTransformFeedbackBuffersEXT(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    firstBinding,
    uint32_t                                    bindingCount,
    const VkBuffer*                             pBuffers,
    const VkDeviceSize*                         pOffsets,
    const VkDeviceSize*                         pSizes);

commandBuffer is the command buffer into which the command is recorded.
firstBinding is the index of the first transform feedback binding whose state is updated by the command.
bindingCount is the number of transform feedback bindings whose state is updated by the command.
pBuffers is a pointer to an array of buffer handles.
pOffsets is a pointer to an array of buffer offsets.
pSizes is an optional array of buffer sizes, specifying the maximum number of bytes to capture to the corresponding transform feedback buffer. If pSizes is NULL, or the value of the pSizes array element is VK_WHOLE_SIZE, then the maximum bytes captured will be the size of the corresponding buffer minus the buffer offset.

The values taken from elements i of pBuffers, pOffsets and pSizes replace the current state for the transform feedback binding firstBinding + i, for i in [0, bindingCount). The transform feedback binding is updated to start at the offset indicated by pOffsets[i] from the start of the buffer pBuffers[i].

Valid Usage

VUID-vkCmdBindTransformFeedbackBuffersEXT-transformFeedback-02355
VkPhysicalDeviceTransformFeedbackFeaturesEXT::transformFeedback must be enabled
VUID-vkCmdBindTransformFeedbackBuffersEXT-firstBinding-02356
firstBinding must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBuffers
VUID-vkCmdBindTransformFeedbackBuffersEXT-firstBinding-02357
The sum of firstBinding and bindingCount must be less than or equal to VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBuffers
VUID-vkCmdBindTransformFeedbackBuffersEXT-pOffsets-02358
All elements of pOffsets must be less than the size of the corresponding element in pBuffers
VUID-vkCmdBindTransformFeedbackBuffersEXT-pOffsets-02359
All elements of pOffsets must be a multiple of 4
VUID-vkCmdBindTransformFeedbackBuffersEXT-pBuffers-02360
All elements of pBuffers must have been created with the VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT flag
VUID-vkCmdBindTransformFeedbackBuffersEXT-pSize-02361
If the optional pSize array is specified, each element of pSizes must either be VK_WHOLE_SIZE, or be less than or equal to VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBufferSize
VUID-vkCmdBindTransformFeedbackBuffersEXT-pSizes-02362
All elements of pSizes must be less than or equal to the size of the corresponding buffer in pBuffers
VUID-vkCmdBindTransformFeedbackBuffersEXT-pOffsets-02363
All elements of pOffsets plus pSizes, where the pSizes, element is not VK_WHOLE_SIZE, must be less than or equal to the size of the corresponding element in pBuffers
VUID-vkCmdBindTransformFeedbackBuffersEXT-pBuffers-02364
Each element of pBuffers that is non-sparse must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdBindTransformFeedbackBuffersEXT-None-02365
Transform feedback must not be active when the vkCmdBindTransformFeedbackBuffersEXT command is recorded

Valid Usage (Implicit)

VUID-vkCmdBindTransformFeedbackBuffersEXT-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdBindTransformFeedbackBuffersEXT-pBuffers-parameter
pBuffers must be a valid pointer to an array of bindingCount valid VkBuffer handles
VUID-vkCmdBindTransformFeedbackBuffersEXT-pOffsets-parameter
pOffsets must be a valid pointer to an array of bindingCount VkDeviceSize values
VUID-vkCmdBindTransformFeedbackBuffersEXT-pSizes-parameter
If pSizes is not NULL, pSizes must be a valid pointer to an array of bindingCount VkDeviceSize values
VUID-vkCmdBindTransformFeedbackBuffersEXT-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdBindTransformFeedbackBuffersEXT-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdBindTransformFeedbackBuffersEXT-bindingCount-arraylength
If pSizes is not NULL, bindingCount must be greater than 0
VUID-vkCmdBindTransformFeedbackBuffersEXT-commonparent
Both of commandBuffer, and the elements of pBuffers must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

Transform feedback for specific transform feedback buffers is made active by calling:

void vkCmdBeginTransformFeedbackEXT(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    firstCounterBuffer,
    uint32_t                                    counterBufferCount,
    const VkBuffer*                             pCounterBuffers,
    const VkDeviceSize*                         pCounterBufferOffsets);

commandBuffer is the command buffer into which the command is recorded.
firstCounterBuffer is the index of the first transform feedback buffer corresponding to pCounterBuffers[0] and pCounterBufferOffsets[0].
counterBufferCount is the size of the pCounterBuffers and pCounterBufferOffsets arrays.
pCounterBuffers is an optional array of buffer handles to the counter buffers which contain a 4 byte integer value representing the byte offset from the start of the corresponding transform feedback buffer from where to start capturing vertex data. If the byte offset stored to the counter buffer location was done using vkCmdEndTransformFeedbackEXT it can be used to resume transform feedback from the previous location. If pCounterBuffers is NULL, then transform feedback will start capturing vertex data to byte offset zero in all bound transform feedback buffers. For each element of pCounterBuffers that is VK_NULL_HANDLE, transform feedback will start capturing vertex data to byte zero in the corresponding bound transform feedback buffer.
pCounterBufferOffsets is an optional array of offsets within each of the pCounterBuffers where the counter values were previously written. The location in each counter buffer at these offsets must be large enough to contain 4 bytes of data. This data is the number of bytes captured by the previous transform feedback to this buffer. If pCounterBufferOffsets is NULL, then it is assumed the offsets are zero.

The active transform feedback buffers will capture primitives emitted from the corresponding XfbBuffer in the bound graphics pipeline. Any XfbBuffer emitted that does not output to an active transform feedback buffer will not be captured.

Valid Usage

VUID-vkCmdBeginTransformFeedbackEXT-transformFeedback-02366
VkPhysicalDeviceTransformFeedbackFeaturesEXT::transformFeedback must be enabled
VUID-vkCmdBeginTransformFeedbackEXT-None-02367
Transform feedback must not be active
VUID-vkCmdBeginTransformFeedbackEXT-firstCounterBuffer-02368
firstCounterBuffer must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBuffers
VUID-vkCmdBeginTransformFeedbackEXT-firstCounterBuffer-02369
The sum of firstCounterBuffer and counterBufferCount must be less than or equal to VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBuffers
VUID-vkCmdBeginTransformFeedbackEXT-counterBufferCount-02607
If counterBufferCount is not 0, and pCounterBuffers is not NULL, pCounterBuffers must be a valid pointer to an array of counterBufferCount VkBuffer handles that are either valid or VK_NULL_HANDLE
VUID-vkCmdBeginTransformFeedbackEXT-pCounterBufferOffsets-02370
For each buffer handle in the array, if it is not VK_NULL_HANDLE it must reference a buffer large enough to hold 4 bytes at the corresponding offset from the pCounterBufferOffsets array
VUID-vkCmdBeginTransformFeedbackEXT-pCounterBuffer-02371
If pCounterBuffer is NULL, then pCounterBufferOffsets must also be NULL
VUID-vkCmdBeginTransformFeedbackEXT-pCounterBuffers-02372
For each buffer handle in the pCounterBuffers array that is not VK_NULL_HANDLE it must have been created with a usage value containing VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT
VUID-vkCmdBeginTransformFeedbackEXT-None-02373
Transform feedback must not be made active in a render pass instance with multiview enabled

Valid Usage (Implicit)

VUID-vkCmdBeginTransformFeedbackEXT-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdBeginTransformFeedbackEXT-pCounterBufferOffsets-parameter
If counterBufferCount is not 0, and pCounterBufferOffsets is not NULL, pCounterBufferOffsets must be a valid pointer to an array of counterBufferCount VkDeviceSize values
VUID-vkCmdBeginTransformFeedbackEXT-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdBeginTransformFeedbackEXT-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdBeginTransformFeedbackEXT-renderpass
This command must only be called inside of a render pass instance
VUID-vkCmdBeginTransformFeedbackEXT-commonparent
Both of commandBuffer, and the elements of pCounterBuffers that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Inside

Graphics

Transform feedback for specific transform feedback buffers is made inactive by calling:

void vkCmdEndTransformFeedbackEXT(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    firstCounterBuffer,
    uint32_t                                    counterBufferCount,
    const VkBuffer*                             pCounterBuffers,
    const VkDeviceSize*                         pCounterBufferOffsets);

commandBuffer is the command buffer into which the command is recorded.
firstCounterBuffer is the index of the first transform feedback buffer corresponding to pCounterBuffers[0] and pCounterBufferOffsets[0].
counterBufferCount is the size of the pCounterBuffers and pCounterBufferOffsets arrays.
pCounterBuffers is an optional array of buffer handles to the counter buffers used to record the current byte positions of each transform feedback buffer where the next vertex output data would be captured. This can be used by a subsequent vkCmdBeginTransformFeedbackEXT call to resume transform feedback capture from this position. It can also be used by vkCmdDrawIndirectByteCountEXT to determine the vertex count of the draw call.
pCounterBufferOffsets is an optional array of offsets within each of the pCounterBuffers where the counter values can be written. The location in each counter buffer at these offsets must be large enough to contain 4 bytes of data. The data stored at this location is the byte offset from the start of the transform feedback buffer binding where the next vertex data would be written. If pCounterBufferOffsets is NULL, then it is assumed the offsets are zero.

Valid Usage

VUID-vkCmdEndTransformFeedbackEXT-transformFeedback-02374
VkPhysicalDeviceTransformFeedbackFeaturesEXT::transformFeedback must be enabled
VUID-vkCmdEndTransformFeedbackEXT-None-02375
Transform feedback must be active
VUID-vkCmdEndTransformFeedbackEXT-firstCounterBuffer-02376
firstCounterBuffer must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBuffers
VUID-vkCmdEndTransformFeedbackEXT-firstCounterBuffer-02377
The sum of firstCounterBuffer and counterBufferCount must be less than or equal to VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBuffers
VUID-vkCmdEndTransformFeedbackEXT-counterBufferCount-02608
If counterBufferCount is not 0, and pCounterBuffers is not NULL, pCounterBuffers must be a valid pointer to an array of counterBufferCount VkBuffer handles that are either valid or VK_NULL_HANDLE
VUID-vkCmdEndTransformFeedbackEXT-pCounterBufferOffsets-02378
For each buffer handle in the array, if it is not VK_NULL_HANDLE it must reference a buffer large enough to hold 4 bytes at the corresponding offset from the pCounterBufferOffsets array
VUID-vkCmdEndTransformFeedbackEXT-pCounterBuffer-02379
If pCounterBuffer is NULL, then pCounterBufferOffsets must also be NULL
VUID-vkCmdEndTransformFeedbackEXT-pCounterBuffers-02380
For each buffer handle in the pCounterBuffers array that is not VK_NULL_HANDLE it must have been created with a usage value containing VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT

Valid Usage (Implicit)

VUID-vkCmdEndTransformFeedbackEXT-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdEndTransformFeedbackEXT-pCounterBufferOffsets-parameter
If counterBufferCount is not 0, and pCounterBufferOffsets is not NULL, pCounterBufferOffsets must be a valid pointer to an array of counterBufferCount VkDeviceSize values
VUID-vkCmdEndTransformFeedbackEXT-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdEndTransformFeedbackEXT-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdEndTransformFeedbackEXT-renderpass
This command must only be called inside of a render pass instance
VUID-vkCmdEndTransformFeedbackEXT-commonparent
Both of commandBuffer, and the elements of pCounterBuffers that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Inside

Graphics

25.2. Viewport Swizzle

Each primitive sent to a given viewport has a swizzle and optional negation applied to its clip coordinates. The swizzle that is applied depends on the viewport index, and is controlled by the VkPipelineViewportSwizzleStateCreateInfoNV pipeline state:

typedef struct VkPipelineViewportSwizzleStateCreateInfoNV {
    VkStructureType                                sType;
    const void*                                    pNext;
    VkPipelineViewportSwizzleStateCreateFlagsNV    flags;
    uint32_t                                       viewportCount;
    const VkViewportSwizzleNV*                     pViewportSwizzles;
} VkPipelineViewportSwizzleStateCreateInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
viewportCount is the number of viewport swizzles used by the pipeline.
pViewportSwizzles is a pointer to an array of VkViewportSwizzleNV structures, defining the viewport swizzles.

Valid Usage

VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-01215
viewportCount must match the viewportCount set in VkPipelineViewportStateCreateInfo

Valid Usage (Implicit)

VUID-VkPipelineViewportSwizzleStateCreateInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV
VUID-VkPipelineViewportSwizzleStateCreateInfoNV-flags-zerobitmask
flags must be 0
VUID-VkPipelineViewportSwizzleStateCreateInfoNV-pViewportSwizzles-parameter
pViewportSwizzles must be a valid pointer to an array of viewportCount valid VkViewportSwizzleNV structures
VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-arraylength
viewportCount must be greater than 0

typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV;

VkPipelineViewportSwizzleStateCreateFlagsNV is a bitmask type for setting a mask, but is currently reserved for future use.

The VkPipelineViewportSwizzleStateCreateInfoNV state is set by adding this structure to the pNext chain of a VkPipelineViewportStateCreateInfo structure and setting the graphics pipeline state with vkCreateGraphicsPipelines.

Each viewport specified from 0 to viewportCount - 1 has its x,y,z,w swizzle state set to the corresponding x, y, z and w in the VkViewportSwizzleNV structure. Each component is of type VkViewportCoordinateSwizzleNV, which determines the type of swizzle for that component. The value of x computes the new x component of the position as:

if (x == VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV) x' = x;
if (x == VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV) x' = -x;
if (x == VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV) x' = y;
if (x == VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV) x' = -y;
if (x == VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV) x' = z;
if (x == VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV) x' = -z;
if (x == VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV) x' = w;
if (x == VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV) x' = -w;

Similar selections are performed for the y, z, and w coordinates. This swizzling is applied before clipping and perspective divide. If the swizzle for an active viewport index is not specified, the swizzle for x is VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV, y is VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV, z is VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV and w is VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV.

Viewport swizzle parameters are specified by setting the pNext pointer of VkGraphicsPipelineCreateInfo to point to a VkPipelineViewportSwizzleStateCreateInfoNV structure. VkPipelineViewportSwizzleStateCreateInfoNV uses VkViewportSwizzleNV to set the viewport swizzle parameters.

The VkViewportSwizzleNV structure is defined as:

typedef struct VkViewportSwizzleNV {
    VkViewportCoordinateSwizzleNV    x;
    VkViewportCoordinateSwizzleNV    y;
    VkViewportCoordinateSwizzleNV    z;
    VkViewportCoordinateSwizzleNV    w;
} VkViewportSwizzleNV;

x is a VkViewportCoordinateSwizzleNV value specifying the swizzle operation to apply to the x component of the primitive
y is a VkViewportCoordinateSwizzleNV value specifying the swizzle operation to apply to the y component of the primitive
z is a VkViewportCoordinateSwizzleNV value specifying the swizzle operation to apply to the z component of the primitive
w is a VkViewportCoordinateSwizzleNV value specifying the swizzle operation to apply to the w component of the primitive

Valid Usage (Implicit)

VUID-VkViewportSwizzleNV-x-parameter
x must be a valid VkViewportCoordinateSwizzleNV value
VUID-VkViewportSwizzleNV-y-parameter
y must be a valid VkViewportCoordinateSwizzleNV value
VUID-VkViewportSwizzleNV-z-parameter
z must be a valid VkViewportCoordinateSwizzleNV value
VUID-VkViewportSwizzleNV-w-parameter
w must be a valid VkViewportCoordinateSwizzleNV value

Possible values of the VkViewportSwizzleNV::x, y, z, and w members, specifying swizzling of the corresponding components of primitives, are:

typedef enum VkViewportCoordinateSwizzleNV {
    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0,
    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1,
    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2,
    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3,
    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4,
    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5,
    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6,
    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7,
    VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF
} VkViewportCoordinateSwizzleNV;

These values are described in detail in Viewport Swizzle.

25.3. Flat Shading

Flat shading a vertex output attribute means to assign all vertices of the primitive the same value for that output. The output values assigned are those of the provoking vertex of the primitive. Flat shading is applied to those vertex attributes that match fragment input attributes which are decorated as Flat.

If neither geometry nor tessellation shading is active, the provoking vertex is determined by the primitive topology defined by VkPipelineInputAssemblyStateCreateInfo:topology used to execute the drawing command.

If geometry shading is active, the provoking vertex is determined by the primitive topology defined by the OutputPoints, OutputLineStrips, or OutputTriangleStrips execution mode.

If tessellation shading is active but geometry shading is not, the provoking vertex may be any of the vertices in each primitive.

25.4. Primitive Clipping

Primitives are culled against the cull volume and then clipped to the clip volume. In clip coordinates, the view volume is defined by:

\[\begin{array}{c} -w_c \leq x_c \leq w_c \\ -w_c \leq y_c \leq w_c \\ 0 \leq z_c \leq w_c \end{array}\]

This view volume can be further restricted by as many as VkPhysicalDeviceLimits::maxClipDistances client-defined half-spaces.

The cull volume is the intersection of up to VkPhysicalDeviceLimits::maxCullDistances client-defined half-spaces (if no client-defined cull half-spaces are enabled, culling against the cull volume is skipped).

A shader must write a single cull distance for each enabled cull half-space to elements of the CullDistance array. If the cull distance for any enabled cull half-space is negative for all of the vertices of the primitive under consideration, the primitive is discarded. Otherwise the primitive is clipped against the clip volume as defined below.

The clip volume is the intersection of up to VkPhysicalDeviceLimits::maxClipDistances client-defined half-spaces with the view volume (if no client-defined clip half-spaces are enabled, the clip volume is the view volume).

A shader must write a single clip distance for each enabled clip half-space to elements of the ClipDistance array. Clip half-space i is then given by the set of points satisfying the inequality

: c_i(P) ≥ 0

where c_i(P) is the clip distance i at point P. For point primitives, c_i(P) is simply the clip distance for the vertex in question. For line and triangle primitives, per-vertex clip distances are interpolated using a weighted mean, with weights derived according to the algorithms described in sections Basic Line Segment Rasterization and Basic Polygon Rasterization, using the perspective interpolation equations.

The number of client-defined clip and cull half-spaces that are enabled is determined by the explicit size of the built-in arrays ClipDistance and CullDistance, respectively, declared as an output in the interface of the entry point of the final shader stage before clipping.

If VkPipelineRasterizationDepthClipStateCreateInfoEXT is present in the graphics pipeline state then depth clipping is disabled if VkPipelineRasterizationDepthClipStateCreateInfoEXT::depthClipEnable is VK_FALSE. Otherwise, if VkPipelineRasterizationDepthClipStateCreateInfoEXT is not present, depth clipping is disabled when VkPipelineRasterizationStateCreateInfo::depthClampEnable is VK_TRUE. When depth clipping is disabled, the plane equation

: 0 ≤ z_c ≤ w_c

(see the clip volume definition above) is ignored by view volume clipping (effectively, there is no near or far plane clipping).

If the primitive under consideration is a point or line segment, then clipping passes it unchanged if its vertices lie entirely within the clip volume.

Possible values of VkPhysicalDevicePointClippingProperties::pointClippingBehavior, specifying clipping behavior of a point primitive whose vertex lies outside the clip volume, are:

typedef enum VkPointClippingBehavior {
    VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0,
    VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1,
    VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
    VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,
    VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF
} VkPointClippingBehavior;

or the equivalent

typedef VkPointClippingBehavior VkPointClippingBehaviorKHR;

VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES specifies that the primitive is discarded if the vertex lies outside any clip plane, including the planes bounding the view volume.
VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY specifies that the primitive is discarded only if the vertex lies outside any user clip plane.

If either of a line segment’s vertices lie outside of the clip volume, the line segment may be clipped, with new vertex coordinates computed for each vertex that lies outside the clip volume. A clipped line segment endpoint lies on both the original line segment and the boundary of the clip volume.

This clipping produces a value, 0 ≤ t ≤ 1, for each clipped vertex. If the coordinates of a clipped vertex are P and the original vertices’ coordinates are P₁ and P₂, then t is given by

: P = t P₁ + (1-t) P₂.

editing-note

This is weird - it gives P, not t.

t is used to clip vertex output attributes as described in Clipping Shader Outputs.

If the primitive is a polygon, it passes unchanged if every one of its edges lie entirely inside the clip volume, and it is discarded if every one of its edges lie entirely outside the clip volume. If the edges of the polygon intersect the boundary of the clip volume, the intersecting edges are reconnected by new edges that lie along the boundary of the clip volume - in some cases requiring the introduction of new vertices into a polygon.

If a polygon intersects an edge of the clip volume’s boundary, the clipped polygon must include a point on this boundary edge.

Primitives rendered with user-defined half-spaces must satisfy a complementarity criterion. Suppose a series of primitives is drawn where each vertex i has a single specified clip distance d_i (or a number of similarly specified clip distances, if multiple half-spaces are enabled). Next, suppose that the same series of primitives are drawn again with each such clip distance replaced by -d_i (and the graphics pipeline is otherwise the same). In this case, primitives must not be missing any pixels, and pixels must not be drawn twice in regions where those primitives are cut by the clip planes.

25.5. Clipping Shader Outputs

Next, vertex output attributes are clipped. The output values associated with a vertex that lies within the clip volume are unaffected by clipping. If a primitive is clipped, however, the output values assigned to vertices produced by clipping are clipped.

Let the output values assigned to the two vertices P₁ and P₂ of an unclipped edge be c₁ and c₂. The value of t (see Primitive Clipping) for a clipped point P is used to obtain the output value associated with P as

: c = t c₁ + (1-t) c₂.

(Multiplying an output value by a scalar means multiplying each of x, y, z, and w by the scalar.)

Since this computation is performed in clip space before division by w_c, clipped output values are perspective-correct.

Polygon clipping creates a clipped vertex along an edge of the clip volume’s boundary. This situation is handled by noting that polygon clipping proceeds by clipping against one half-space at a time. Output value clipping is done in the same way, so that clipped points always occur at the intersection of polygon edges (possibly already clipped) with the clip volume’s boundary.

For vertex output attributes whose matching fragment input attributes are decorated with NoPerspective, the value of t used to obtain the output value associated with P will be adjusted to produce results that vary linearly in framebuffer space.

Output attributes of integer or unsigned integer type must always be flat shaded. Flat shaded attributes are constant over the primitive being rasterized (see Basic Line Segment Rasterization and Basic Polygon Rasterization), and no interpolation is performed. The output value c is taken from either c₁ or c₂, since flat shading has already occurred and the two values are identical.

25.6. Controlling Viewport W Scaling

If viewport W scaling is enabled, the W component of the clip coordinate is modified by the provided coefficients from the corresponding viewport as follows.

: w_c' = x_coeff x_c + y_coeff y_c + w_c

The VkPipelineViewportWScalingStateCreateInfoNV structure is defined as:

typedef struct VkPipelineViewportWScalingStateCreateInfoNV {
    VkStructureType                sType;
    const void*                    pNext;
    VkBool32                       viewportWScalingEnable;
    uint32_t                       viewportCount;
    const VkViewportWScalingNV*    pViewportWScalings;
} VkPipelineViewportWScalingStateCreateInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
viewportWScalingEnable controls whether viewport W scaling is enabled.
viewportCount is the number of viewports used by W scaling, and must match the number of viewports in the pipeline if viewport W scaling is enabled.
pViewportWScalings is a pointer to an array of VkViewportWScalingNV structures defining the W scaling parameters for the corresponding viewports. If the viewport W scaling state is dynamic, this member is ignored.

Valid Usage (Implicit)

VUID-VkPipelineViewportWScalingStateCreateInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV
VUID-VkPipelineViewportWScalingStateCreateInfoNV-viewportCount-arraylength
viewportCount must be greater than 0

The VkPipelineViewportWScalingStateCreateInfoNV state is set by adding this structure to the pNext chain of a VkPipelineViewportStateCreateInfo structure and setting the graphics pipeline state with vkCreateGraphicsPipelines.

If the bound pipeline state object was not created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled, viewport W scaling parameters are specified using the pViewportWScalings member of VkPipelineViewportWScalingStateCreateInfoNV in the pipeline state object. If the pipeline state object was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled, the viewport transformation parameters are dynamically set and changed with the command:

void vkCmdSetViewportWScalingNV(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    firstViewport,
    uint32_t                                    viewportCount,
    const VkViewportWScalingNV*                 pViewportWScalings);

commandBuffer is the command buffer into which the command will be recorded.
firstViewport is the index of the first viewport whose parameters are updated by the command.
viewportCount is the number of viewports whose parameters are updated by the command.
pViewportWScalings is a pointer to an array of VkViewportWScalingNV structures specifying viewport parameters.

The viewport parameters taken from element i of pViewportWScalings replace the current state for the viewport index firstViewport + i, for i in [0, viewportCount).

Valid Usage

VUID-vkCmdSetViewportWScalingNV-firstViewport-01323
firstViewport must be less than VkPhysicalDeviceLimits::maxViewports
VUID-vkCmdSetViewportWScalingNV-firstViewport-01324
The sum of firstViewport and viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive

Valid Usage (Implicit)

VUID-vkCmdSetViewportWScalingNV-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetViewportWScalingNV-pViewportWScalings-parameter
pViewportWScalings must be a valid pointer to an array of viewportCount VkViewportWScalingNV structures
VUID-vkCmdSetViewportWScalingNV-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetViewportWScalingNV-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdSetViewportWScalingNV-viewportCount-arraylength
viewportCount must be greater than 0

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

Both VkPipelineViewportWScalingStateCreateInfoNV and vkCmdSetViewportWScalingNV use VkViewportWScalingNV to set the viewport transformation parameters.

The VkViewportWScalingNV structure is defined as:

typedef struct VkViewportWScalingNV {
    float    xcoeff;
    float    ycoeff;
} VkViewportWScalingNV;

xcoeff and ycoeff are the viewport’s W scaling factor for x and y respectively.

25.7. Coordinate Transformations

Clip coordinates for a vertex result from shader execution, which yields a vertex coordinate Position.

Perspective division on clip coordinates yields normalized device coordinates, followed by a viewport transformation (see Controlling the Viewport) to convert these coordinates into framebuffer coordinates.

If a vertex in clip coordinates has a position given by

\[\left(\begin{array}{c} x_c \\ y_c \\ z_c \\ w_c \end{array}\right)\]

then the vertex’s normalized device coordinates are

\[\left( \begin{array}{c} x_d \\ y_d \\ z_d \end{array} \right) = \left( \begin{array}{c} \frac{x_c}{w_c} \\ \frac{y_c}{w_c} \\ \frac{z_c}{w_c} \end{array} \right)\]

25.8. Controlling the Viewport

The viewport transformation is determined by the selected viewport’s width and height in pixels, p_x and p_y, respectively, and its center (o_x, o_y) (also in pixels), as well as its depth range min and max determining a depth range scale value p_z and a depth range bias value o_z (defined below). The vertex’s framebuffer coordinates (x_f, y_f, z_f) are given by

: x_f = (p_x / 2) x_d + o_x
: y_f = (p_y / 2) y_d + o_y
: z_f = p_z × z_d + o_z

Multiple viewports are available, numbered zero up to VkPhysicalDeviceLimits::maxViewports minus one. The number of viewports used by a pipeline is controlled by the viewportCount member of the VkPipelineViewportStateCreateInfo structure used in pipeline creation.

The VkPipelineViewportStateCreateInfo structure is defined as:

typedef struct VkPipelineViewportStateCreateInfo {
    VkStructureType                       sType;
    const void*                           pNext;
    VkPipelineViewportStateCreateFlags    flags;
    uint32_t                              viewportCount;
    const VkViewport*                     pViewports;
    uint32_t                              scissorCount;
    const VkRect2D*                       pScissors;
} VkPipelineViewportStateCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
viewportCount is the number of viewports used by the pipeline.
pViewports is a pointer to an array of VkViewport structures, defining the viewport transforms. If the viewport state is dynamic, this member is ignored.
scissorCount is the number of scissors and must match the number of viewports.
pScissors is a pointer to an array of VkRect2D structures defining the rectangular bounds of the scissor for the corresponding viewport. If the scissor state is dynamic, this member is ignored.

Valid Usage

VUID-VkPipelineViewportStateCreateInfo-viewportCount-01216
If the multiple viewports feature is not enabled, viewportCount must be 1
VUID-VkPipelineViewportStateCreateInfo-scissorCount-01217
If the multiple viewports feature is not enabled, scissorCount must be 1
VUID-VkPipelineViewportStateCreateInfo-viewportCount-01218
viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive
VUID-VkPipelineViewportStateCreateInfo-scissorCount-01219
scissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive
VUID-VkPipelineViewportStateCreateInfo-scissorCount-01220
scissorCount and viewportCount must be identical
VUID-VkPipelineViewportStateCreateInfo-x-02821
The x and y members of offset member of any element of pScissors must be greater than or equal to 0
VUID-VkPipelineViewportStateCreateInfo-offset-02822
Evaluation of (offset.x + extent.width) must not cause a signed integer addition overflow for any element of pScissors
VUID-VkPipelineViewportStateCreateInfo-offset-02823
Evaluation of (offset.y + extent.height) must not cause a signed integer addition overflow for any element of pScissors
VUID-VkPipelineViewportStateCreateInfo-viewportWScalingEnable-01726
If the viewportWScalingEnable member of a VkPipelineViewportWScalingStateCreateInfoNV structure included in the pNext chain is VK_TRUE, the viewportCount member of the VkPipelineViewportWScalingStateCreateInfoNV structure must be equal to viewportCount

Valid Usage (Implicit)

VUID-VkPipelineViewportStateCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO
VUID-VkPipelineViewportStateCreateInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineViewportCoarseSampleOrderStateCreateInfoNV, VkPipelineViewportExclusiveScissorStateCreateInfoNV, VkPipelineViewportShadingRateImageStateCreateInfoNV, VkPipelineViewportSwizzleStateCreateInfoNV, or VkPipelineViewportWScalingStateCreateInfoNV
VUID-VkPipelineViewportStateCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkPipelineViewportStateCreateInfo-flags-zerobitmask
flags must be 0
VUID-VkPipelineViewportStateCreateInfo-viewportCount-arraylength
viewportCount must be greater than 0
VUID-VkPipelineViewportStateCreateInfo-scissorCount-arraylength
scissorCount must be greater than 0

typedef VkFlags VkPipelineViewportStateCreateFlags;

VkPipelineViewportStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

A vertex processing stage can direct each primitive to zero or more viewports. The destination viewports for a primitive are selected by the last active vertex processing stage that has an output variable decorated with ViewportIndex (selecting a single viewport) or ViewportMaskNV (selecting multiple viewports). The viewport transform uses the viewport corresponding to either the value assigned to ViewportIndex or one of the bits set in ViewportMaskNV, and taken from an implementation-dependent vertex of each primitive. If ViewportIndex or any of the bits in ViewportMaskNV are outside the range zero to viewportCount minus one for a primitive, or if the last active vertex processing stage did not assign a value to either ViewportIndex or ViewportMaskNV for all vertices of a primitive due to flow control, the values resulting from the viewport transformation of the vertices of such primitives are undefined. If the last vertex processing stage does not have an output decorated with ViewportIndex or ViewportMaskNV, the viewport numbered zero is used by the viewport transformation.

A single vertex can be used in more than one individual primitive, in primitives such as VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP. In this case, the viewport transformation is applied separately for each primitive.

If the bound pipeline state object was not created with the VK_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 VK_DYNAMIC_STATE_VIEWPORT dynamic state enabled, the viewport transformation parameters are dynamically set and changed with the command:

void vkCmdSetViewport(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    firstViewport,
    uint32_t                                    viewportCount,
    const VkViewport*                           pViewports);

commandBuffer is the command buffer into which the command will be recorded.
firstViewport is the index of the first viewport whose parameters are updated by the command.
viewportCount is the number of viewports whose parameters are updated by the command.
pViewports is a pointer to an array of VkViewport structures specifying viewport parameters.

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

VUID-vkCmdSetViewport-firstViewport-01222
firstViewport must be less than VkPhysicalDeviceLimits::maxViewports
VUID-vkCmdSetViewport-firstViewport-01223
The sum of firstViewport and viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive
VUID-vkCmdSetViewport-firstViewport-01224
If the multiple viewports feature is not enabled, firstViewport must be 0
VUID-vkCmdSetViewport-viewportCount-01225
If the multiple viewports feature is not enabled, viewportCount must be 1

Valid Usage (Implicit)

VUID-vkCmdSetViewport-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetViewport-pViewports-parameter
pViewports must be a valid pointer to an array of viewportCount valid VkViewport structures
VUID-vkCmdSetViewport-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetViewport-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdSetViewport-viewportCount-arraylength
viewportCount must be greater than 0

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

Both VkPipelineViewportStateCreateInfo and vkCmdSetViewport use VkViewport to set the viewport transformation parameters.

The VkViewport structure is defined as:

typedef struct VkViewport {
    float    x;
    float    y;
    float    width;
    float    height;
    float    minDepth;
    float    maxDepth;
} VkViewport;

x and y are the viewport’s upper left corner (x,y).
width and height are the viewport’s width and height, respectively.
minDepth and maxDepth are the depth range for the viewport. It is valid for minDepth to be greater than or equal to maxDepth.

The framebuffer depth coordinate z_f may be represented using either a fixed-point or floating-point representation. However, a floating-point representation must be used if the depth/stencil attachment has a floating-point depth component. If an m-bit fixed-point representation is used, we assume that it represents each value \(\frac{k}{2^m - 1}\), where k ∈ { 0, 1, …, 2^m-1 }, as k (e.g. 1.0 is represented in binary as a string of all ones).

The viewport parameters shown in the above equations are found from these values as

: o_x = x + width / 2
: o_y = y + height / 2
: o_z = minDepth
: p_x = width
: p_y = height
: p_z = maxDepth - minDepth.

The application can specify a negative term for height, which has the effect of negating the y coordinate in clip space before performing the transform. When using a negative height, the application should also adjust the y value to point to the lower left corner of the viewport instead of the upper left corner. Using the negative height allows the application to avoid having to negate the y component of the Position output from the last vertex processing stage in shaders that also target other graphics APIs.

The width and height of the implementation-dependent maximum viewport dimensions must be greater than or equal to the width and height of the largest image which can be created and attached to a framebuffer.

The floating-point viewport bounds are represented with an implementation-dependent precision.

Valid Usage

VUID-VkViewport-width-01770
width must be greater than 0.0
VUID-VkViewport-width-01771
width must be less than or equal to VkPhysicalDeviceLimits::maxViewportDimensions[0]
VUID-VkViewport-height-01773
The absolute value of height must be less than or equal to VkPhysicalDeviceLimits::maxViewportDimensions[1]
VUID-VkViewport-x-01774
x must be greater than or equal to viewportBoundsRange[0]
VUID-VkViewport-x-01232
(x + width) must be less than or equal to viewportBoundsRange[1]
VUID-VkViewport-y-01775
y must be greater than or equal to viewportBoundsRange[0]
VUID-VkViewport-y-01776
y must be less than or equal to viewportBoundsRange[1]
VUID-VkViewport-y-01777
(y + height) must be greater than or equal to viewportBoundsRange[0]
VUID-VkViewport-y-01233
(y + height) must be less than or equal to viewportBoundsRange[1]
VUID-VkViewport-minDepth-01234
Unless VK_EXT_depth_range_unrestricted extension is enabled minDepth must be between 0.0 and 1.0, inclusive
VUID-VkViewport-maxDepth-01235
Unless VK_EXT_depth_range_unrestricted extension is enabled maxDepth must be between 0.0 and 1.0, inclusive

26. Rasterization

Rasterization is the process by which a primitive is converted to a two-dimensional image. Each point of this image contains associated data such as depth, color, or other attributes.

Rasterizing a primitive begins by determining which squares of an integer grid in framebuffer coordinates are occupied by the primitive, and assigning one or more depth values to each such square. This process is described below for points, lines, and polygons.

A grid square, including its (x,y) framebuffer coordinates, z (depth), and associated data added by fragment shaders, is called a fragment. A fragment is located by its upper left corner, which lies on integer grid coordinates.

Rasterization operations also refer to a fragment’s sample locations, which are offset by fractional values from its upper left corner. The rasterization rules for points, lines, and triangles involve testing whether each sample location is inside the primitive. Fragments need not actually be square, and rasterization rules are not affected by the aspect ratio of fragments. Display of non-square grids, however, will cause rasterized points and line segments to appear fatter in one direction than the other.

We assume that fragments are square, since it simplifies antialiasing and texturing. After rasterization, fragments are processed by the early per-fragment tests, if enabled.

Several factors affect rasterization, including the members of VkPipelineRasterizationStateCreateInfo and VkPipelineMultisampleStateCreateInfo.

The VkPipelineRasterizationStateCreateInfo structure is defined as:

typedef struct VkPipelineRasterizationStateCreateInfo {
    VkStructureType                            sType;
    const void*                                pNext;
    VkPipelineRasterizationStateCreateFlags    flags;
    VkBool32                                   depthClampEnable;
    VkBool32                                   rasterizerDiscardEnable;
    VkPolygonMode                              polygonMode;
    VkCullModeFlags                            cullMode;
    VkFrontFace                                frontFace;
    VkBool32                                   depthBiasEnable;
    float                                      depthBiasConstantFactor;
    float                                      depthBiasClamp;
    float                                      depthBiasSlopeFactor;
    float                                      lineWidth;
} VkPipelineRasterizationStateCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
depthClampEnable controls whether to clamp the fragment’s depth values as described in Depth Test. If the pipeline is not created with VkPipelineRasterizationDepthClipStateCreateInfoEXT present then enabling depth clamp will also disable clipping primitives to the z planes of the frustrum as described in Primitive Clipping. Otherwise depth clipping is controlled by the state set in VkPipelineRasterizationDepthClipStateCreateInfoEXT.
rasterizerDiscardEnable controls whether primitives are discarded immediately before the rasterization stage.
polygonMode is the triangle rendering mode. See VkPolygonMode.
cullMode is the triangle facing direction used for primitive culling. See VkCullModeFlagBits.
frontFace is a VkFrontFace value specifying the front-facing triangle orientation to be used for culling.
depthBiasEnable controls whether to bias fragment depth values.
depthBiasConstantFactor is a scalar factor controlling the constant depth value added to each fragment.
depthBiasClamp is the maximum (or minimum) depth bias of a fragment.
depthBiasSlopeFactor is a scalar factor applied to a fragment’s slope in depth bias calculations.
lineWidth is the width of rasterized line segments.

The application can also add a VkPipelineRasterizationStateRasterizationOrderAMD structure to the pNext chain of a VkPipelineRasterizationStateCreateInfo structure. This structure enables selecting the rasterization order to use when rendering with the corresponding graphics pipeline as described in Rasterization Order.

Valid Usage

VUID-VkPipelineRasterizationStateCreateInfo-depthClampEnable-00782
If the depth clamping feature is not enabled, depthClampEnable must be VK_FALSE
VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01507
If the non-solid fill modes feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL or VK_POLYGON_MODE_FILL_RECTANGLE_NV
VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01414
If the VK_NV_fill_rectangle extension is not enabled, polygonMode must not be VK_POLYGON_MODE_FILL_RECTANGLE_NV

Valid Usage (Implicit)

VUID-VkPipelineRasterizationStateCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO
VUID-VkPipelineRasterizationStateCreateInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineRasterizationConservativeStateCreateInfoEXT, VkPipelineRasterizationDepthClipStateCreateInfoEXT, VkPipelineRasterizationLineStateCreateInfoEXT, VkPipelineRasterizationStateRasterizationOrderAMD, or VkPipelineRasterizationStateStreamCreateInfoEXT
VUID-VkPipelineRasterizationStateCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkPipelineRasterizationStateCreateInfo-flags-zerobitmask
flags must be 0
VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-parameter
polygonMode must be a valid VkPolygonMode value
VUID-VkPipelineRasterizationStateCreateInfo-cullMode-parameter
cullMode must be a valid combination of VkCullModeFlagBits values
VUID-VkPipelineRasterizationStateCreateInfo-frontFace-parameter
frontFace must be a valid VkFrontFace value

typedef VkFlags VkPipelineRasterizationStateCreateFlags;

VkPipelineRasterizationStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

If the pNext chain of VkPipelineRasterizationStateCreateInfo includes a VkPipelineRasterizationDepthClipStateCreateInfoEXT structure, then that structure controls whether depth clipping is enabled or disabled.

The VkPipelineRasterizationDepthClipStateCreateInfoEXT structure is defined as:

typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT {
    VkStructureType                                        sType;
    const void*                                            pNext;
    VkPipelineRasterizationDepthClipStateCreateFlagsEXT    flags;
    VkBool32                                               depthClipEnable;
} VkPipelineRasterizationDepthClipStateCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
depthClipEnable controls whether depth clipping is enabled as described in Primitive Clipping.

Valid Usage (Implicit)

VUID-VkPipelineRasterizationDepthClipStateCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT
VUID-VkPipelineRasterizationDepthClipStateCreateInfoEXT-flags-zerobitmask
flags must be 0

typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT;

VkPipelineRasterizationDepthClipStateCreateFlagsEXT is a bitmask type for setting a mask, but is currently reserved for future use.

The VkPipelineMultisampleStateCreateInfo structure is defined as:

typedef struct VkPipelineMultisampleStateCreateInfo {
    VkStructureType                          sType;
    const void*                              pNext;
    VkPipelineMultisampleStateCreateFlags    flags;
    VkSampleCountFlagBits                    rasterizationSamples;
    VkBool32                                 sampleShadingEnable;
    float                                    minSampleShading;
    const VkSampleMask*                      pSampleMask;
    VkBool32                                 alphaToCoverageEnable;
    VkBool32                                 alphaToOneEnable;
} VkPipelineMultisampleStateCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
rasterizationSamples is a VkSampleCountFlagBits specifying the number of samples used in rasterization.
sampleShadingEnable can be used to enable Sample Shading.
minSampleShading specifies a minimum fraction of sample shading if sampleShadingEnable is set to VK_TRUE.
pSampleMask is a bitmask of static coverage information that is ANDed with the coverage information generated during rasterization, as described in Sample Mask.
alphaToCoverageEnable controls whether a temporary coverage value is generated based on the alpha component of the fragment’s first color output as specified in the Multisample Coverage section.
alphaToOneEnable controls whether the alpha component of the fragment’s first color output is replaced with one as described in Multisample Coverage.

Valid Usage

VUID-VkPipelineMultisampleStateCreateInfo-sampleShadingEnable-00784
If the sample rate shading feature is not enabled, sampleShadingEnable must be VK_FALSE
VUID-VkPipelineMultisampleStateCreateInfo-alphaToOneEnable-00785
If the alpha to one feature is not enabled, alphaToOneEnable must be VK_FALSE
VUID-VkPipelineMultisampleStateCreateInfo-minSampleShading-00786
minSampleShading must be in the range [0,1]
VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-01415
If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the subpass has any color attachments and rasterizationSamples is greater than the number of color samples, then sampleShadingEnable must be VK_FALSE

Valid Usage (Implicit)

VUID-VkPipelineMultisampleStateCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO
VUID-VkPipelineMultisampleStateCreateInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineCoverageModulationStateCreateInfoNV, VkPipelineCoverageReductionStateCreateInfoNV, VkPipelineCoverageToColorStateCreateInfoNV, or VkPipelineSampleLocationsStateCreateInfoEXT
VUID-VkPipelineMultisampleStateCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkPipelineMultisampleStateCreateInfo-flags-zerobitmask
flags must be 0
VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-parameter
rasterizationSamples must be a valid VkSampleCountFlagBits value
VUID-VkPipelineMultisampleStateCreateInfo-pSampleMask-parameter
If pSampleMask is not NULL, pSampleMask must be a valid pointer to an array of \(\lceil{\mathit{rasterizationSamples} \over 32}\rceil\) VkSampleMask values

typedef VkFlags VkPipelineMultisampleStateCreateFlags;

VkPipelineMultisampleStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

Rasterization only generates fragments which cover one or more pixels inside the framebuffer. Pixels outside the framebuffer are never considered covered in the fragment. Fragments which would be produced by application of any of the primitive rasterization rules described below but which lie outside the framebuffer are not produced, nor are they processed by any later stage of the pipeline, including any of the early per-fragment tests described in Early Per-Fragment Tests.

Surviving fragments are processed by fragment shaders. Fragment shaders determine associated data for fragments, and can also modify or replace their assigned depth values.

When the VK_AMD_mixed_attachment_samples and VK_NV_framebuffer_mixed_samples extensions are not enabled, if the subpass for which this pipeline is being created uses color and/or depth/stencil attachments, then rasterizationSamples must be the same as the sample count for those subpass attachments.

When the VK_AMD_mixed_attachment_samples extension is enabled, if the subpass for which this pipeline is being created uses color and/or depth/stencil attachments, then rasterizationSamples must be the same as the maximum of the sample counts of those subpass attachments.

When the VK_NV_framebuffer_mixed_samples extension is enabled, rasterizationSamples must match the sample count of the depth/stencil attachment if present, otherwise must be greater than or equal to the sample count of the color attachments, if present.

If the VK_NV_coverage_reduction_mode extension is enabled, the coverage reduction mode specified by VkPipelineCoverageReductionStateCreateInfoNV::coverageReductionMode, the rasterizationSamples member of pMultisampleState and the sample counts for the color and depth/stencil attachments (if present) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV

If the subpass for which this pipeline is being created does not use color or depth/stencil attachments, rasterizationSamples must follow the rules for a zero-attachment subpass.

26.1. Discarding Primitives Before Rasterization

Primitives are discarded before rasterization if the rasterizerDiscardEnable member of VkPipelineRasterizationStateCreateInfo is enabled. When enabled, primitives are discarded after they are processed by the last active shader stage in the pipeline before rasterization.

26.2. Controlling the Vertex Stream Used for Rasterization

By default vertex data output from the last vertex processing stage are directed to vertex stream zero. Geometry shaders can emit primitives to multiple independent vertex streams. Each vertex emitted by the geometry shader is directed at one of the vertex streams. As vertices are received on each vertex stream, they are arranged into primitives of the type specified by the geometry shader output primitive type. The shading language instructions OpEndPrimitive and OpEndStreamPrimitive can be used to end the primitive being assembled on a given vertex stream and start a new empty primitive of the same type. An implementation supports up to VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams streams, which is at least 1. The individual streams are numbered 0 through maxTransformFeedbackStreams minus 1. There is no requirement on the order of the streams to which vertices are emitted, and the number of vertices emitted to each vertex stream can be completely independent, subject only to the VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreamDataSize and VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBufferDataSize limits. The primitives output from all vertex streams are passed to the transform feedback stage to be captured to transform feedback buffers in the manner specified by the last vertex processing stage shader’s XfbBuffer, XfbStride, and Offsets decorations on the output interface variables in the graphics pipeline. To use a vertex stream other than zero, or to use multiple streams, the GeometryStreams capability must be specified.

By default, the primitives output from vertex stream zero are rasterized. If the implementation supports the VkPhysicalDeviceTransformFeedbackPropertiesEXT::transformFeedbackRasterizationStreamSelect property it is possible to rasterize a vertex stream other than zero.

By default, geometry shaders that emit vertices to multiple vertex streams are limited to using only the OutputPoints output primitive type. If the implementation supports the VkPhysicalDeviceTransformFeedbackPropertiesEXT::transformFeedbackStreamsLinesTriangles property it is possible to emit OutputLineStrip or OutputTriangleStrip in addition to OutputPoints.

The vertex stream used for rasterization is specified by adding a VkPipelineRasterizationStateStreamCreateInfoEXT structure to the pNext chain of a VkPipelineRasterizationStateCreateInfo structure.

The VkPipelineRasterizationStateStreamCreateInfoEXT structure is defined as:

typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT {
    VkStructureType                                     sType;
    const void*                                         pNext;
    VkPipelineRasterizationStateStreamCreateFlagsEXT    flags;
    uint32_t                                            rasterizationStream;
} VkPipelineRasterizationStateStreamCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
rasterizationStream is the vertex stream selected for rasterization.

If this structure is not present, rasterizationStream is assumed to be zero.

Valid Usage

VUID-VkPipelineRasterizationStateStreamCreateInfoEXT-geometryStreams-02324
VkPhysicalDeviceTransformFeedbackFeaturesEXT::geometryStreams must be enabled
VUID-VkPipelineRasterizationStateStreamCreateInfoEXT-rasterizationStream-02325
rasterizationStream must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams
VUID-VkPipelineRasterizationStateStreamCreateInfoEXT-rasterizationStream-02326
rasterizationStream must be zero if VkPhysicalDeviceTransformFeedbackPropertiesEXT::transformFeedbackRasterizationStreamSelect is VK_FALSE

Valid Usage (Implicit)

VUID-VkPipelineRasterizationStateStreamCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT
VUID-VkPipelineRasterizationStateStreamCreateInfoEXT-flags-zerobitmask
flags must be 0

typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT;

VkPipelineRasterizationStateStreamCreateFlagsEXT is a bitmask type for setting a mask, but is currently reserved for future use.

26.3. Rasterization Order

Within a subpass of a render pass instance, for a given (x,y,layer,sample) sample location, the following operations are guaranteed to execute in rasterization order, for each separate primitive that includes that sample location:

Scissor test
Exclusive scissor test
Sample mask generation
Depth bounds test
Stencil test, stencil op and stencil write
Depth test and depth write
Sample counting for occlusion queries
Fragment Coverage To Color
coverage reduction
Blending, logic operations, and color writes

Each of these operations is atomically executed for each primitive and sample location.

Execution of these operations for each primitive in a subpass occurs in an order determined by the application.

The rasterization order to use for a graphics pipeline is specified by adding a VkPipelineRasterizationStateRasterizationOrderAMD structure to the pNext chain of a VkPipelineRasterizationStateCreateInfo structure.

The VkPipelineRasterizationStateRasterizationOrderAMD structure is defined as:

typedef struct VkPipelineRasterizationStateRasterizationOrderAMD {
    VkStructureType            sType;
    const void*                pNext;
    VkRasterizationOrderAMD    rasterizationOrder;
} VkPipelineRasterizationStateRasterizationOrderAMD;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
rasterizationOrder is a VkRasterizationOrderAMD value specifying the primitive rasterization order to use.

Valid Usage (Implicit)

VUID-VkPipelineRasterizationStateRasterizationOrderAMD-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD
VUID-VkPipelineRasterizationStateRasterizationOrderAMD-rasterizationOrder-parameter
rasterizationOrder must be a valid VkRasterizationOrderAMD value

If the VK_AMD_rasterization_order device extension is not enabled or the application does not request a particular rasterization order through specifying a VkPipelineRasterizationStateRasterizationOrderAMD structure then the rasterization order used by the graphics pipeline defaults to VK_RASTERIZATION_ORDER_STRICT_AMD.

Possible values of VkPipelineRasterizationStateRasterizationOrderAMD::rasterizationOrder, specifying the primitive rasterization order, are:

typedef enum VkRasterizationOrderAMD {
    VK_RASTERIZATION_ORDER_STRICT_AMD = 0,
    VK_RASTERIZATION_ORDER_RELAXED_AMD = 1,
    VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF
} VkRasterizationOrderAMD;

VK_RASTERIZATION_ORDER_STRICT_AMD specifies that operations for each primitive in a subpass must occur in primitive order.
VK_RASTERIZATION_ORDER_RELAXED_AMD specifies that operations for each primitive in a subpass may not occur in primitive order.

26.4. Multisampling

Multisampling is a mechanism to antialias all Vulkan primitives: points, lines, and polygons. The technique is to sample all primitives multiple times at each pixel. Each sample in each framebuffer attachment has storage for a color, depth, and/or stencil value, such that per-fragment operations apply to each sample independently. The color sample values can be later resolved to a single color (see Resolving Multisample Images and the Render Pass chapter for more details on how to resolve multisample images to non-multisample images).

Vulkan defines rasterization rules for single-sample modes in a way that is equivalent to a multisample mode with a single sample in the center of each fragment.

Each fragment includes a coverage value with rasterizationSamples bits (see Sample Mask). Each fragment includes rasterizationSamples depth values and sets of associated data. An implementation may choose to assign the same associated data to more than one sample. The location for evaluating such associated data may be anywhere within the fragment area including the fragment’s center location (x_f,y_f) or any of the sample locations. When rasterizationSamples is VK_SAMPLE_COUNT_1_BIT, the fragment’s center location must be used. The different associated data values need not all be evaluated at the same location. Each fragment thus consists of integer x and y grid coordinates, rasterizationSamples depth values and sets of associated data, and a coverage value with rasterizationSamples bits.

It is understood that each pixel has rasterizationSamples locations associated with it. These locations are exact positions, rather than regions or areas, and each is referred to as a sample point. The sample points associated with a pixel must be located inside or on the boundary of the unit square that is considered to bound the pixel. Furthermore, the relative locations of sample points may be identical for each pixel in the framebuffer, or they may differ.

If the render pass has a fragment density map attachment, each fragment only has rasterizationSamples locations associated with it regardless of how many pixels are covered in the fragment area. Fragment sample locations are defined as if the fragment had an area of (1,1) and its sample points must be located within these bounds. Their actual location in the framebuffer is calculated by scaling the sample location by the fragment area. Attachments with storage for multiple samples per pixel are located at the pixel sample locations. Otherwise, the fragment’s sample locations are generally used for evaluation of associated data and fragment operations.

If the current pipeline includes a fragment shader with one or more variables in its interface decorated with Sample and Input, the data associated with those variables will be assigned independently for each sample. The values for each sample must be evaluated at the location of the sample. The data associated with any other variables not decorated with Sample and Input need not be evaluated independently for each sample.

If the standardSampleLocations member of VkPhysicalDeviceLimits is VK_TRUE, then the sample counts VK_SAMPLE_COUNT_1_BIT, VK_SAMPLE_COUNT_2_BIT, VK_SAMPLE_COUNT_4_BIT, VK_SAMPLE_COUNT_8_BIT, and VK_SAMPLE_COUNT_16_BIT have sample locations as listed in the following table, with the ith entry in the table corresponding to bit i in the sample masks. VK_SAMPLE_COUNT_32_BIT and VK_SAMPLE_COUNT_64_BIT do not have standard sample locations. Locations are defined relative to an origin in the upper left corner of the fragment.

Table 31. Standard sample locations
`VK_SAMPLE_COUNT_1_BIT`	`VK_SAMPLE_COUNT_2_BIT`	`VK_SAMPLE_COUNT_4_BIT`	`VK_SAMPLE_COUNT_8_BIT`	`VK_SAMPLE_COUNT_16_BIT`
(0.5,0.5)	(0.75,0.75) (0.25,0.25)	(0.375, 0.125) (0.875, 0.375) (0.125, 0.625) (0.625, 0.875)	(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)	(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)

Color images created with multiple samples per pixel use a compression technique where there are two arrays of data associated with each pixel. The first array contains one element per sample where each element stores an index to the second array defining the fragment mask of the pixel. The second array contains one element per color fragment and each element stores a unique color value in the format of the image. With this compression technique it is not always necessary to actually use unique storage locations for each color sample: when multiple samples share the same color value the fragment mask may have two samples referring to the same color fragment. The number of color fragments is determined by the samples member of the VkImageCreateInfo structure used to create the image. The VK_AMD_shader_fragment_mask device extension provides shader instructions enabling the application to get direct access to the fragment mask and the individual color fragment values.

Figure 16. Fragment Mask

26.5. Custom Sample Locations

Applications can also control the sample locations used for rasterization.

If the pNext chain of the VkPipelineMultisampleStateCreateInfo structure specified at pipeline creation time includes a VkPipelineSampleLocationsStateCreateInfoEXT structure, then that structure controls the sample locations used when rasterizing primitives with the pipeline.

The VkPipelineSampleLocationsStateCreateInfoEXT structure is defined as:

typedef struct VkPipelineSampleLocationsStateCreateInfoEXT {
    VkStructureType             sType;
    const void*                 pNext;
    VkBool32                    sampleLocationsEnable;
    VkSampleLocationsInfoEXT    sampleLocationsInfo;
} VkPipelineSampleLocationsStateCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
sampleLocationsEnable controls whether custom sample locations are used. If sampleLocationsEnable is VK_FALSE, the default sample locations are used and the values specified in sampleLocationsInfo are ignored.
sampleLocationsInfo is the sample locations to use during rasterization if sampleLocationsEnable is VK_TRUE and the graphics pipeline is not created with VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT.

Valid Usage (Implicit)

VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT
VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sampleLocationsInfo-parameter
sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure

The VkSampleLocationsInfoEXT structure is defined as:

typedef struct VkSampleLocationsInfoEXT {
    VkStructureType               sType;
    const void*                   pNext;
    VkSampleCountFlagBits         sampleLocationsPerPixel;
    VkExtent2D                    sampleLocationGridSize;
    uint32_t                      sampleLocationsCount;
    const VkSampleLocationEXT*    pSampleLocations;
} VkSampleLocationsInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
sampleLocationsPerPixel is a VkSampleCountFlagBits specifying the number of sample locations per pixel.
sampleLocationGridSize is the size of the sample location grid to select custom sample locations for.
sampleLocationsCount is the number of sample locations in pSampleLocations.
pSampleLocations is a pointer to an array of sampleLocationsCount VkSampleLocationEXT structures.

This structure can be used either to specify the sample locations to be used for rendering or to specify the set of sample locations an image subresource has been last rendered with for the purposes of layout transitions of depth/stencil images created with VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT.

The sample locations in pSampleLocations specify sampleLocationsPerPixel number of sample locations for each pixel in the grid of the size specified in sampleLocationGridSize. The sample location for sample i at the pixel grid location (x,y) is taken from pSampleLocations[(x + y * sampleLocationGridSize.width) * sampleLocationsPerPixel + i].

If the render pass has a fragment density map, the implementation will choose the sample locations for the fragment and the contents of pSampleLocations may be ignored.

Valid Usage

VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-01526
sampleLocationsPerPixel must be a bit value that is set in VkPhysicalDeviceSampleLocationsPropertiesEXT::sampleLocationSampleCounts
VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-01527
sampleLocationsCount must equal sampleLocationsPerPixel × sampleLocationGridSize.width × sampleLocationGridSize.height

Valid Usage (Implicit)

VUID-VkSampleLocationsInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT
VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter
If sampleLocationsPerPixel is not 0, sampleLocationsPerPixel must be a valid VkSampleCountFlagBits value
VUID-VkSampleLocationsInfoEXT-pSampleLocations-parameter
If sampleLocationsCount is not 0, pSampleLocations must be a valid pointer to an array of sampleLocationsCount VkSampleLocationEXT structures

The VkSampleLocationEXT structure is defined as:

typedef struct VkSampleLocationEXT {
    float    x;
    float    y;
} VkSampleLocationEXT;

x is the horizontal coordinate of the sample’s location.
y is the vertical coordinate of the sample’s location.

The domain space of the sample location coordinates has an upper-left origin within the pixel in framebuffer space.

The values specified in a VkSampleLocationEXT structure are always clamped to the implementation-dependent sample location coordinate range [sampleLocationCoordinateRange[0],sampleLocationCoordinateRange[1]] that can be queried by adding a VkPhysicalDeviceSampleLocationsPropertiesEXT structure to the pNext chain of VkPhysicalDeviceProperties2.

The custom sample locations used for rasterization when VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable is VK_TRUE are specified by the VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsInfo property of the bound graphics pipeline, if the pipeline was not created with VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT enabled.

Otherwise, the sample locations used for rasterization are set by calling vkCmdSetSampleLocationsEXT:

void vkCmdSetSampleLocationsEXT(
    VkCommandBuffer                             commandBuffer,
    const VkSampleLocationsInfoEXT*             pSampleLocationsInfo);

commandBuffer is the command buffer into which the command will be recorded.
pSampleLocationsInfo is the sample locations state to set.

Valid Usage

VUID-vkCmdSetSampleLocationsEXT-sampleLocationsPerPixel-01529
The sampleLocationsPerPixel member of pSampleLocationsInfo must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with
VUID-vkCmdSetSampleLocationsEXT-variableSampleLocations-01530
If VkPhysicalDeviceSampleLocationsPropertiesEXT::variableSampleLocations is VK_FALSE then the current render pass must have been begun by specifying a VkRenderPassSampleLocationsBeginInfoEXT structure whose pPostSubpassSampleLocations member contains an element with a subpassIndex matching the current subpass index and the sampleLocationsInfo member of that element must match the sample locations state pointed to by pSampleLocationsInfo

Valid Usage (Implicit)

VUID-vkCmdSetSampleLocationsEXT-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetSampleLocationsEXT-pSampleLocationsInfo-parameter
pSampleLocationsInfo must be a valid pointer to a valid VkSampleLocationsInfoEXT structure
VUID-vkCmdSetSampleLocationsEXT-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetSampleLocationsEXT-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

26.6. Shading Rate Image

The shading rate image feature allows pipelines to use a shading rate image to control the fragment area and the minimum number of fragment shader invocations launched for each fragment. When the shading rate image is enabled, the rasterizer determines a base shading rate for each region of the framebuffer covered by a primitive by fetching a value from the shading rate image and translating it to a shading rate using a per-viewport shading rate palette. This base shading rate is then adjusted to derive a final shading rate. The final shading rate specifyies the fragment area and fragment shader invocation count to use for fragments generated in the region.

If the pNext chain of VkPipelineViewportStateCreateInfo includes a VkPipelineViewportShadingRateImageStateCreateInfoNV structure, then that structure includes parameters that control the shading rate.

The VkPipelineViewportShadingRateImageStateCreateInfoNV structure is defined as:

typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV {
    VkStructureType                  sType;
    const void*                      pNext;
    VkBool32                         shadingRateImageEnable;
    uint32_t                         viewportCount;
    const VkShadingRatePaletteNV*    pShadingRatePalettes;
} VkPipelineViewportShadingRateImageStateCreateInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
shadingRateImageEnable specifies whether shading rate image and palettes are used during rasterization.
viewportCount specifies the number of per-viewport palettes used to translate values stored in shading rate images.
pShadingRatePalettes is a pointer to an array of VkShadingRatePaletteNV structures defining the palette for each viewport. If the shading rate palette state is dynamic, this member is ignored.

If this structure is not present, shadingRateImageEnable is considered to be VK_FALSE, and the shading rate image and palettes are not used.

Valid Usage

VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-viewportCount-02054
If the multiple viewports feature is not enabled, viewportCount must be 0 or 1
VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-viewportCount-02055
viewportCount must be less than or equal to VkPhysicalDeviceLimits::maxViewports
VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-shadingRateImageEnable-02056
If shadingRateImageEnable is VK_TRUE, viewportCount must be equal to the viewportCount member of VkPipelineViewportStateCreateInfo
VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-pDynamicStates-02057
If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV, pShadingRatePalettes must be a valid pointer to an array of viewportCount VkShadingRatePaletteNV structures

Valid Usage (Implicit)

VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV
VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-pShadingRatePalettes-parameter
If viewportCount is not 0, and pShadingRatePalettes is not NULL, pShadingRatePalettes must be a valid pointer to an array of viewportCount valid VkShadingRatePaletteNV structures

When shading rate image usage is enabled in the bound pipeline, the pipeline uses a shading rate image specified by the command:

void vkCmdBindShadingRateImageNV(
    VkCommandBuffer                             commandBuffer,
    VkImageView                                 imageView,
    VkImageLayout                               imageLayout);

commandBuffer is the command buffer into which the command will be recorded.
imageView is an image view handle specifying the shading rate image. imageView may be set to VK_NULL_HANDLE, which is equivalent to specifying a view of an image filled with zero values.
imageLayout is the layout that the image subresources accessible from imageView will be in when the shading rate image is accessed.

Valid Usage

VUID-vkCmdBindShadingRateImageNV-None-02058
The shading rate image feature must be enabled.
VUID-vkCmdBindShadingRateImageNV-imageView-02059
If imageView is not VK_NULL_HANDLE, it must be a valid VkImageView handle of type VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY.
VUID-vkCmdBindShadingRateImageNV-imageView-02060
If imageView is not VK_NULL_HANDLE, it must have a format of VK_FORMAT_R8_UINT.
VUID-vkCmdBindShadingRateImageNV-imageView-02061
If imageView is not VK_NULL_HANDLE, it must have been created with a usage value including VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV
VUID-vkCmdBindShadingRateImageNV-imageView-02062
If imageView is not VK_NULL_HANDLE, imageLayout must match the actual VkImageLayout of each subresource accessible from imageView at the time the subresource is accessed.
VUID-vkCmdBindShadingRateImageNV-imageLayout-02063
If imageView is not VK_NULL_HANDLE, imageLayout must be VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV or VK_IMAGE_LAYOUT_GENERAL.

Valid Usage (Implicit)

VUID-vkCmdBindShadingRateImageNV-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdBindShadingRateImageNV-imageView-parameter
If imageView is not VK_NULL_HANDLE, imageView must be a valid VkImageView handle
VUID-vkCmdBindShadingRateImageNV-imageLayout-parameter
imageLayout must be a valid VkImageLayout value
VUID-vkCmdBindShadingRateImageNV-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdBindShadingRateImageNV-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdBindShadingRateImageNV-commonparent
Both of commandBuffer, and imageView that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

When the shading rate image is enabled in the current pipeline, rasterizing a primitive covering the pixel with coordinates (x,y) will fetch a shading rate index value from the shading rate image bound by vkCmdBindShadingRateImageNV. If the shading rate image view has a type of VK_IMAGE_VIEW_TYPE_2D, the lookup will use texel coordinates (u,v) where \(u = \lfloor \frac{x}{twidth} \rfloor\), \(v = \lfloor \frac{y}{theight} \rfloor\), and \(twidth\) and \(theight\) are the width and height of the implementation-dependent shading rate texel size. If the shading rate image view has a type of VK_IMAGE_VIEW_TYPE_2D_ARRAY, the lookup will use texel coordinates (u,v) to extract a texel from the layer l, where l is the layer of the framebuffer being rendered to. If l is greater than or equal to the number of layers in the image view, layer zero will be used.

If the bound shading rate image view is not VK_NULL_HANDLE and contains a texel with coordinates (u,v) in layer l (if applicable), the single unsigned integer component for that texel will be used as the shading rate index. If the (u,v) coordinate is outside the extents of the subresource used by the shading rate image view, or if the image view is VK_NULL_HANDLE, the shading rate index is zero. If the shading rate image view has multiple mipmap levels, the base level identified by VkImageSubresourceRange::baseMipLevel will be used.

A shading rate index is mapped to a base shading rate using a lookup table called the shading rate image palette. There is a separate palette for each viewport. The number of entries in each palette is given by the implementation-dependent shading rate image palette size.

If a pipeline state object is created with VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV enabled, the per-viewport shading rate image palettes are set by the command:

void vkCmdSetViewportShadingRatePaletteNV(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    firstViewport,
    uint32_t                                    viewportCount,
    const VkShadingRatePaletteNV*               pShadingRatePalettes);

commandBuffer is the command buffer into which the command will be recorded.
firstViewport is the index of the first viewport whose shading rate palette is updated by the command.
viewportCount is the number of viewports whose shading rate palettes are updated by the command.
pShadingRatePalettes is a pointer to an array of VkShadingRatePaletteNV structures defining the palette for each viewport.

Valid Usage

VUID-vkCmdSetViewportShadingRatePaletteNV-None-02064
The shading rate image feature must be enabled.
VUID-vkCmdSetViewportShadingRatePaletteNV-firstViewport-02066
firstViewport must be less than VkPhysicalDeviceLimits::maxViewports
VUID-vkCmdSetViewportShadingRatePaletteNV-firstViewport-02067
The sum of firstViewport and viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive
VUID-vkCmdSetViewportShadingRatePaletteNV-firstViewport-02068
If the multiple viewports feature is not enabled, firstViewport must be 0
VUID-vkCmdSetViewportShadingRatePaletteNV-viewportCount-02069
If the multiple viewports feature is not enabled, viewportCount must be 1

Valid Usage (Implicit)

VUID-vkCmdSetViewportShadingRatePaletteNV-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetViewportShadingRatePaletteNV-pShadingRatePalettes-parameter
pShadingRatePalettes must be a valid pointer to an array of viewportCount valid VkShadingRatePaletteNV structures
VUID-vkCmdSetViewportShadingRatePaletteNV-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetViewportShadingRatePaletteNV-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdSetViewportShadingRatePaletteNV-viewportCount-arraylength
viewportCount must be greater than 0

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

The VkShadingRatePaletteNV structure specifies to contents of a single shading rate image palette and is defined as:

typedef struct VkShadingRatePaletteNV {
    uint32_t                              shadingRatePaletteEntryCount;
    const VkShadingRatePaletteEntryNV*    pShadingRatePaletteEntries;
} VkShadingRatePaletteNV;

shadingRatePaletteEntryCount specifies the number of entries in the shading rate image palette.
pShadingRatePaletteEntries is a pointer to an array of VkShadingRatePaletteEntryNV enums defining the shading rate for each palette entry.

Valid Usage

VUID-VkShadingRatePaletteNV-shadingRatePaletteEntryCount-02071
shadingRatePaletteEntryCount must be between 1 and VkPhysicalDeviceShadingRateImagePropertiesNV::shadingRatePaletteSize, inclusive

Valid Usage (Implicit)

VUID-VkShadingRatePaletteNV-pShadingRatePaletteEntries-parameter
pShadingRatePaletteEntries must be a valid pointer to an array of shadingRatePaletteEntryCount valid VkShadingRatePaletteEntryNV values
VUID-VkShadingRatePaletteNV-shadingRatePaletteEntryCount-arraylength
shadingRatePaletteEntryCount must be greater than 0

To determine the base shading rate image, a shading rate index i is mapped to array element i in the array pShadingRatePaletteEntries for the palette corresponding to the viewport used for the fragment. If i is greater than or equal to the palette size shadingRatePaletteEntryCount, the base shading rate is undefined.

The supported shading rate image palette entries are defined by VkShadingRatePaletteEntryNV:

typedef enum VkShadingRatePaletteEntryNV {
    VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0,
    VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1,
    VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2,
    VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3,
    VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4,
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5,
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6,
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7,
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8,
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9,
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10,
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11,
    VK_SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = 0x7FFFFFFF
} VkShadingRatePaletteEntryNV;

The following table indicates the width and height (in pixels) of each fragment generated using the indicated shading rate, as well as the maximum number of fragment shader invocations launched for each fragment. When processing regions of a primitive that have a shading rate of VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV, no fragments will be generated in that region.

Shading Rate	Width	Height	Invocations
`VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV`	0	0	0
`VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV`	1	1	16
`VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV`	1	1	8
`VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV`	1	1	4
`VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV`	1	1	2
`VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV`	1	1	1
`VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV`	2	1	1
`VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV`	1	2	1
`VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV`	2	2	1
`VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV`	4	2	1
`VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV`	2	4	1
`VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV`	4	4	1

When the shading rate image is disabled, a shading rate of VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV will be used as the base shading rate.

Once a base shading rate has been established, it is adjusted to produce a final shading rate. First, if the base shading rate uses multiple pixels for each fragment, the implementation may reduce the fragment area to ensure that the total number of coverage samples for all pixels in a fragment does not exceed an implementation-dependent maximum.

If sample shading is active in the current pipeline and would result in processing n (n > 1) unique samples per fragment when the shading rate image is disabled, the shading rate is adjusted in an implementation-dependent manner to increase the number of fragment shader invocations spawned by the primitive. If the shading rate indicates fs pixels per fragment and fs is greater than n, the fragment area is adjusted so each fragment has approximately \(fs \over n\) pixels. Otherwise, if the shading rate indicates ipf invocations per fragment, the fragment area will be adjusted to a single pixel with approximately \(ipf \times n \over fs\) invocations per fragment.

If sample shading occurs due to the use of a fragment shader input variable decorated with SampleId or SamplePosition, the shading rate is ignored. Each fragment will have a single pixel and will spawn up to totalSamples fragment shader invocations, as when using sample shading without a shading rate image.

Finally, if the shading rate specifies multiple fragment shader invocations per fragment, the total number of invocations in the shading rate is clamped to be no larger than the value of totalSamples used for sample shading.

When the final shading rate for a primitive covering pixel (x,y) has a fragment area of \(fw \times fh\), the fragment for that pixel will cover all pixels with coordinates (x',y') that satisfy the equations:

\[\begin{aligned} \lfloor \frac{x}{fw} \rfloor == \lfloor \frac{x'}{fw} \rfloor \end{aligned}\]

\[\begin{aligned} \lfloor \frac{y}{fh} \rfloor == \lfloor \frac{y'}{fh} \rfloor \end{aligned}\]

This combined fragment is considered to have multiple coverage samples; the total number of samples in this fragment is given by \(samples = fw \times fh \times rs\) where rs indicates the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples specified at pipeline creation time. The set of coverage samples in the fragment is the union of the per-pixel coverage samples in each of the fragment’s pixels The location and order of coverage samples within each pixel in the combined fragment are assigned as described in Multisampling and Custom Sample Locations. Each coverage sample in the set of pixels belonging to the combined fragment is assigned a unique sample number in the range [0,samples-1]. If the shadingRateCoarseSampleOrder feature is supported, the order of coverage samples can be specified for each combination of fragment area and coverage sample count. If this feature is not supported, the sample order is implementation-dependent.

If the pNext chain of VkPipelineViewportStateCreateInfo includes a VkPipelineViewportCoarseSampleOrderStateCreateInfoNV structure, then that structure includes parameters that control the order of coverage samples in fragments larger than one pixel.

The VkPipelineViewportCoarseSampleOrderStateCreateInfoNV structure is defined as:

typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV {
    VkStructureType                       sType;
    const void*                           pNext;
    VkCoarseSampleOrderTypeNV             sampleOrderType;
    uint32_t                              customSampleOrderCount;
    const VkCoarseSampleOrderCustomNV*    pCustomSampleOrders;
} VkPipelineViewportCoarseSampleOrderStateCreateInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
sampleOrderType specifies the mechanism used to order coverage samples in fragments larger than one pixel.
customSampleOrderCount specifies the number of custom sample orderings to use when ordering coverage samples.
pCustomSampleOrders is a pointer to an array of customSampleOrderCount VkCoarseSampleOrderCustomNV structures, each of which specifies the coverage sample order for a single combination of fragment area and coverage sample count.

If this structure is not present, sampleOrderType is considered to be VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV.

If sampleOrderType is VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV, the coverage sample order used for any combination of fragment area and coverage sample count not enumerated in pCustomSampleOrders will be identical to that used for VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV.

If the pipeline was created with VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV, the contents of this structure (if present) are ignored, and the coverage sample order is instead specified by vkCmdSetCoarseSampleOrderNV.

Valid Usage

VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-sampleOrderType-02072
If sampleOrderType is not VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV, customSamplerOrderCount must be 0
VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-pCustomSampleOrders-02234
The array pCustomSampleOrders must not contain two structures with matching values for both the shadingRate and sampleCount members.

Valid Usage (Implicit)

VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV
VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-sampleOrderType-parameter
sampleOrderType must be a valid VkCoarseSampleOrderTypeNV value
VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-pCustomSampleOrders-parameter
If customSampleOrderCount is not 0, pCustomSampleOrders must be a valid pointer to an array of customSampleOrderCount valid VkCoarseSampleOrderCustomNV structures

The type VkCoarseSampleOrderTypeNV specifies the technique used to order coverage samples in fragments larger than one pixel, and is defined as:

typedef enum VkCoarseSampleOrderTypeNV {
    VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0,
    VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1,
    VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2,
    VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3,
    VK_COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
} VkCoarseSampleOrderTypeNV;

VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV specifies that coverage samples will be ordered in an implementation-dependent manner.
VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV specifies that coverage samples will be ordered according to the array of custom orderings provided in either the pCustomSampleOrders member of VkPipelineViewportCoarseSampleOrderStateCreateInfoNV or the pCustomSampleOrders member of vkCmdSetCoarseSampleOrderNV.
VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV specifies that coverage samples will be ordered sequentially, sorted first by pixel coordinate (in row-major order) and then by coverage sample number.
VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV specifies that coverage samples will be ordered sequentially, sorted first by coverage sample number and then by pixel coordinate (in row-major order).

When using a coarse sample order of VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV for a fragment with an upper-left corner of \((fx,fy)\) with a width of \(fw \times fh\) and \(fsc\) coverage samples per pixel, sample \(cs\) of the fragment will be assigned to sample \(fs\) of pixel \((px,py)\) will be assigned as follows:

\[\begin{aligned} px = & fx + (\lfloor {cs \over fsc} \rfloor \text{ \% } fw) \\ py = & fy + \lfloor {cs \over {fsc \times fw}} \rfloor \\ fs = & cs \text{ \% } fsc \end{aligned}\]

When using a coarse sample order of VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV, sample \(cs\) will be assigned as follows:

\[\begin{aligned} px = & fx + cs \text{ \% } fw \\ py = & (fy + \lfloor {cs \over fw} \rfloor \text{ \% } fh) \\ fs = & \lfloor {cs \over {fw \times fh}} \rfloor \end{aligned}\]

The VkCoarseSampleOrderCustomNV structure is used with a coverage sample ordering type of VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV to specify the order of coverage samples for one combination of fragment width, fragment height, and coverage sample count. The structure is defined as:

typedef struct VkCoarseSampleOrderCustomNV {
    VkShadingRatePaletteEntryNV        shadingRate;
    uint32_t                           sampleCount;
    uint32_t                           sampleLocationCount;
    const VkCoarseSampleLocationNV*    pSampleLocations;
} VkCoarseSampleOrderCustomNV;

shadingRate is a shading rate palette entry that identifies the fragment width and height for the combination of fragment area and per-pixel coverage sample count to control.
sampleCount identifies the per-pixel coverage sample count for the combination of fragment area and coverage sample count to control.
sampleLocationCount specifies the number of sample locations in the custom ordering.
pSampleLocations is a pointer to an array of VkCoarseSampleOrderCustomNV structures specifying the location of each sample in the custom ordering.

When using a custom sample ordering, element i in pSampleLocations specifies a specific pixel and per-pixel coverage sample number that corresponds to the coverage sample numbered i in the multi-pixel fragment.

Valid Usage

VUID-VkCoarseSampleOrderCustomNV-shadingRate-02073
shadingRate must be a shading rate that generates fragments with more than one pixel.
VUID-VkCoarseSampleOrderCustomNV-sampleCount-02074
sampleCount must correspond to a sample count enumerated in VkSampleCountFlags whose corresponding bit is set in VkPhysicalDeviceLimits::framebufferNoAttachmentsSampleCounts.
VUID-VkCoarseSampleOrderCustomNV-sampleLocationCount-02075
sampleLocationCount must be equal to the product of sampleCount, the fragment width for shadingRate, and the fragment height for shadingRate.
VUID-VkCoarseSampleOrderCustomNV-sampleLocationCount-02076
sampleLocationCount must be less than or equal to the value of VkPhysicalDeviceShadingRateImagePropertiesNV::shadingRateMaxCoarseSamples.
VUID-VkCoarseSampleOrderCustomNV-pSampleLocations-02077
The array pSampleLocations must contain exactly one entry for every combination of valid values for pixelX, pixelY, and sample in the structure VkCoarseSampleOrderCustomNV.

Valid Usage (Implicit)

VUID-VkCoarseSampleOrderCustomNV-shadingRate-parameter
shadingRate must be a valid VkShadingRatePaletteEntryNV value
VUID-VkCoarseSampleOrderCustomNV-pSampleLocations-parameter
pSampleLocations must be a valid pointer to an array of sampleLocationCount VkCoarseSampleLocationNV structures
VUID-VkCoarseSampleOrderCustomNV-sampleLocationCount-arraylength
sampleLocationCount must be greater than 0

The VkCoarseSampleLocationNV structure identifies a specific pixel and sample number for one of the coverage samples in a fragment that is larger than one pixel. This structure is defined as:

typedef struct VkCoarseSampleLocationNV {
    uint32_t    pixelX;
    uint32_t    pixelY;
    uint32_t    sample;
} VkCoarseSampleLocationNV;

pixelX is added to the x coordinate of the upper-leftmost pixel of each fragment to identify the pixel containing the coverage sample.
pixelY is added to the y coordinate of the upper-leftmost pixel of each fragment to identify the pixel containing the coverage sample.
sample is the number of the coverage sample in the pixel identified by pixelX and pixelY.

Valid Usage

VUID-VkCoarseSampleLocationNV-pixelX-02078
pixelX must be less than the width (in pixels) of the fragment.
VUID-VkCoarseSampleLocationNV-pixelY-02079
pixelY must be less than the height (in pixels) of the fragment.
VUID-VkCoarseSampleLocationNV-sample-02080
sample must be less than the number of coverage samples in each pixel belonging to the fragment.

If a pipeline state object is created with VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV enabled, the order of coverage samples in fragments larger than one pixel is set by the command:

void vkCmdSetCoarseSampleOrderNV(
    VkCommandBuffer                             commandBuffer,
    VkCoarseSampleOrderTypeNV                   sampleOrderType,
    uint32_t                                    customSampleOrderCount,
    const VkCoarseSampleOrderCustomNV*          pCustomSampleOrders);

commandBuffer is the command buffer into which the command will be recorded.
sampleOrderType specifies the mechanism used to order coverage samples in fragments larger than one pixel.
customSampleOrderCount specifies the number of custom sample orderings to use when ordering coverage samples.
pCustomSampleOrders is a pointer to an array of VkCoarseSampleOrderCustomNV structures, each of which specifies the coverage sample order for a single combination of fragment area and coverage sample count.

Valid Usage

VUID-vkCmdSetCoarseSampleOrderNV-sampleOrderType-02081
If sampleOrderType is not VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV, customSamplerOrderCount must be 0
VUID-vkCmdSetCoarseSampleOrderNV-pCustomSampleOrders-02235
The array pCustomSampleOrders must not contain two structures with matching values for both the shadingRate and sampleCount members.

Valid Usage (Implicit)

VUID-vkCmdSetCoarseSampleOrderNV-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetCoarseSampleOrderNV-sampleOrderType-parameter
sampleOrderType must be a valid VkCoarseSampleOrderTypeNV value
VUID-vkCmdSetCoarseSampleOrderNV-pCustomSampleOrders-parameter
If customSampleOrderCount is not 0, pCustomSampleOrders must be a valid pointer to an array of customSampleOrderCount valid VkCoarseSampleOrderCustomNV structures
VUID-vkCmdSetCoarseSampleOrderNV-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetCoarseSampleOrderNV-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

If the final shading rate for a primitive covering pixel (x,y) results in n invocations per pixel (n > 1), n separate fragment shader invocations will be generated for the fragment. Each coverage sample in the fragment will be assigned to one of the n fragment shader invocations in an implementation-dependent manner. The outputs from the fragment output interface of each shader invocation will be broadcast to all of the framebuffer samples associated with the invocation. If none of the coverage samples associated with a fragment shader invocation is covered by a primitive, the implementation may discard the fragment shader invocation for those samples.

If the final shading rate for a primitive covering pixel (x,y) results in a fragment containing multiple pixels, a single set of fragment shader invocations will be generated for all pixels in the combined fragment. Outputs from the fragment output interface will be broadcast to all covered framebuffer samples belonging to the fragment. If the fragment shader executes code discarding the fragment, none of the samples of the fragment will be updated.

26.7. Sample Shading

Sample shading can be used to specify a minimum number of unique samples to process for each fragment. If sample shading is enabled an implementation must provide a minimum of max(⌈ minSampleShadingFactor × totalSamples ⌉, 1) unique associated data for each fragment, where minSampleShadingFactor is the minimum fraction of sample shading. If the VK_AMD_mixed_attachment_samples extension is enabled and the subpass uses color attachments, totalSamples is the number of samples of the color attachments. Otherwise, totalSamples is the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples specified at pipeline creation time. These are associated with the samples in an implementation-dependent manner. When minSampleShadingFactor is 1.0, a separate set of associated data are evaluated for each sample, and each set of values is evaluated at the sample location.

Sample shading is enabled for a graphics pipeline:

If the interface of the fragment shader entry point of the graphics pipeline includes an input variable decorated with SampleId or SamplePosition. In this case minSampleShadingFactor takes the value 1.0.
Else if the sampleShadingEnable member of the VkPipelineMultisampleStateCreateInfo structure specified when creating the graphics pipeline is set to VK_TRUE. In this case minSampleShadingFactor takes the value of VkPipelineMultisampleStateCreateInfo::minSampleShading.

Otherwise, sample shading is considered disabled.

26.8. Barycentric Interpolation

When the fragmentShaderBarycentric feature is enabled, the PerVertexNV interpolation decoration can be used with fragment shader inputs to indicate that the decorated inputs do not have associated data in the fragment. Such inputs can only be accessed in a fragment shader using an array index whose value (0, 1, or 2) identifies one of the vertices of the primitive that produced the fragment.

When tessellation, geometry shading, and mesh shading are not active, fragment shader inputs decorated with PerVertexNV will take values from one of the vertices of the primitive that produced the fragment, identified by the extra index provided in SPIR-V code accessing the input. If the n vertices passed to a draw call are numbered 0 through n-1, and the point, line, and triangle primitives produced by the draw call are numbered with consecutive integers beginning with zero, the following table indicates the original vertex numbers used for index values of 0, 1, and 2. If an input decorated with PerVertexNV is accessed with any other vertex index value, the value obtained is undefined.

Primitive Topology Vertex 0 Vertex 1 Vertex 2

VK_PRIMITIVE_TOPOLOGY_POINT_LIST

VK_PRIMITIVE_TOPOLOGY_LINE_LIST

2i+1

VK_PRIMITIVE_TOPOLOGY_LINE_STRIP

i+1

VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST

3i+1

3i+2

VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP (even)

i+1

i+2

VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP (odd)

i+2

i+1

VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN

i+1

i+2

VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY

4i+1

4i+2

VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY

i+1

i+2

VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY

6i+2

6i+4

VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY (even)

2i+2

2i+4

VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY (odd)

2i+4

2i+2

When geometry or mesh shading is active, primitives processed by fragment shaders are assembled from the vertices emitted by the geometry or mesh shader. In this case, the vertices used for fragment shader inputs decorated with PerVertexNV are derived by treating the primitives produced by the shader as though they were specified by a draw call and consulting the table above.

When using tessellation without geometry shading, the tessellator produces primitives in an implementation-dependent manner. While there is no defined vertex ordering for inputs decorated with PerVertexNV, the vertex ordering used in this case will be consistent with the ordering used to derive the values of inputs decorated with BaryCoordNV or BaryCoordNoPerspNV.

Fragment shader inputs decorated with BaryCoordNV or BaryCoordNoPerspNV hold three-component vectors with barycentric weights that indicate the location of the fragment relative to the screen-space locations of vertices of its primitive. For point primitives, such variables are always assigned the value (1,0,0). For line primitives, the built-ins are obtained by interpolating an attribute whose values for the vertices numbered 0 and 1 are (1,0,0) and (0,1,0), respectively. For polygon primitives, the built-ins are obtained by interpolating an attribute whose values for the vertices numbered 0, 1, and 2 are (1,0,0), (0,1,0), and (0,0,1), respectively. For BaryCoordNV, the values are obtained using perspective interpolation. For BaryCoordNoPerspNV, the values are obtained using linear interpolation.

26.9. Points

A point is drawn by generating a set of fragments in the shape of a square centered around the vertex of the point. Each vertex has an associated point size that controls the width/height of that square. The point size is taken from the (potentially clipped) shader built-in PointSize written by:

the geometry shader, if active;
the tessellation evaluation shader, if active and no geometry shader is active;
the vertex shader, otherwise

and clamped to the implementation-dependent point size range [pointSizeRange[0],pointSizeRange[1]]. The value written to PointSize must be greater than zero.

Not all point sizes need be supported, but the size 1.0 must be supported. The range of supported sizes and the size of evenly-spaced gradations within that range are implementation-dependent. The range and gradations are obtained from the pointSizeRange and pointSizeGranularity 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 point sizes may also be supported. There is no requirement that these sizes be equally spaced. If an unsupported size is requested, the nearest supported size is used instead.

Further, if the render pass has a fragment density map attachment, point size may be rounded by the implementation to a multiple of the fragment’s width or height.

26.9.1. Basic Point Rasterization

Point rasterization produces a fragment for each fragment area group of framebuffer pixels with one or more sample points that intersect a region centered at the point’s (x_f,y_f). This region is a square with side equal to the current point size. Coverage bits that correspond to sample points that intersect the region are 1, other coverage bits are 0. All fragments produced in rasterizing a point are assigned the same associated data, which are those of the vertex corresponding to the point. However, the fragment shader built-in PointCoord contains point sprite texture coordinates. The s and t point sprite texture coordinates vary from zero to one across the point horizontally left-to-right and top-to-bottom, respectively. The following formulas are used to evaluate s and t:

\[s = {1 \over 2} + { \left( x_p - x_f \right) \over \text{size} }\]

\[t = {1 \over 2} + { \left( y_p - y_f \right) \over \text{size} }\]

where size is the point’s size; (x_p,y_p) is the location at which the point sprite coordinates are evaluated - this may be the framebuffer coordinates of the fragment center, or the location of a sample; and (x_f,y_f) is the exact, unrounded framebuffer coordinate of the vertex for the point.

26.10. Line Segments

Line segment rasterization options are controlled by the VkPipelineRasterizationLineStateCreateInfoEXT structure.

The VkPipelineRasterizationLineStateCreateInfoEXT structure is defined as:

typedef struct VkPipelineRasterizationLineStateCreateInfoEXT {
    VkStructureType               sType;
    const void*                   pNext;
    VkLineRasterizationModeEXT    lineRasterizationMode;
    VkBool32                      stippledLineEnable;
    uint32_t                      lineStippleFactor;
    uint16_t                      lineStipplePattern;
} VkPipelineRasterizationLineStateCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
lineRasterizationMode is a VkLineRasterizationModeEXT value selecting the style of line rasterization.
stippledLineEnable enables stippled line rasterization.
lineStippleFactor is the repeat factor used in stippled line rasterization.
lineStipplePattern is the bit pattern used in stippled line rasterization.

Valid Usage

VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02768
If lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the rectangularLines feature must be enabled
VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02769
If lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT, then the bresenhamLines feature must be enabled
VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02770
If lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT, then the smoothLines feature must be enabled
VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02771
If stippledLineEnable is VK_TRUE and lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled
VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02772
If stippledLineEnable is VK_TRUE and lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT, then the stippledBresenhamLines feature must be enabled
VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02773
If stippledLineEnable is VK_TRUE and lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT, then the stippledSmoothLines feature must be enabled
VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02774
If stippledLineEnable is VK_TRUE and lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE

Valid Usage (Implicit)

VUID-VkPipelineRasterizationLineStateCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT
VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-parameter
lineRasterizationMode must be a valid VkLineRasterizationModeEXT value

Possible values of VkPipelineRasterizationLineStateCreateInfoEXT::lineRasterizationMode are:

typedef enum VkLineRasterizationModeEXT {
    VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0,
    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1,
    VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2,
    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3,
    VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
} VkLineRasterizationModeEXT;

VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT is equivalent to VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT if VkPhysicalDeviceLimits::strictLines is VK_TRUE, otherwise lines are drawn as non-strictLines parallelograms. Both of these modes are defined in Basic Line Segment Rasterization.
VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT specifies lines drawn as if they were rectangles extruded from the line
VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT specifies lines drawn by determining which pixel diamonds the line intersects and exits, as defined in Bresenham Line Segment Rasterization.
VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT specifies lines drawn if they were rectangles extruded from the line, with alpha falloff, as defined in Smooth Lines.

Each line segment has an associated width. The line width is specified by the VkPipelineRasterizationStateCreateInfo::lineWidth property of the currently active pipeline, if the pipeline was not created with VK_DYNAMIC_STATE_LINE_WIDTH enabled.

Otherwise, the line width is set by calling vkCmdSetLineWidth:

void vkCmdSetLineWidth(
    VkCommandBuffer                             commandBuffer,
    float                                       lineWidth);

commandBuffer is the command buffer into which the command will be recorded.
lineWidth is the width of rasterized line segments.

Valid Usage

VUID-vkCmdSetLineWidth-lineWidth-00788
If the wide lines feature is not enabled, lineWidth must be 1.0

Valid Usage (Implicit)

VUID-vkCmdSetLineWidth-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetLineWidth-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetLineWidth-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

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.

Further, if the render pass has a fragment density map attachment, line width may be rounded by the implementation to a multiple of the fragment’s width or height.

26.10.1. Basic Line Segment Rasterization

If the lineRasterizationMode member of VkPipelineRasterizationLineStateCreateInfoEXT is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, rasterized line segments produce fragments which intersect a rectangle centered on the line segment. Two of the edges are parallel to the specified line segment; each is at a distance of one-half the current width from that segment in directions perpendicular to the direction of the line. The other two edges pass through the line endpoints and are perpendicular to the direction of the specified line segment. Coverage bits that correspond to sample points that intersect the rectangle are 1, other coverage bits are 0.

Next we specify how the data associated with each rasterized fragment are obtained. Let p_r = (x_d, y_d) be the framebuffer coordinates at which associated data are evaluated. This may be the center of a fragment or the location of a sample within the fragment. When rasterizationSamples is VK_SAMPLE_COUNT_1_BIT, the fragment center must be used. Let p_a = (x_a, y_a) and p_b = (x_b,y_b) be initial and final endpoints of the line segment, respectively. Set

\[t = {{( \mathbf{p}_r - \mathbf{p}_a ) \cdot ( \mathbf{p}_b - \mathbf{p}_a )} \over {\| \mathbf{p}_b - \mathbf{p}_a \|^2 }}\]

(Note that t = 0 at p_a and t = 1 at p_b. Also note that this calculation projects the vector from p_a to p_r onto the line, and thus computes the normalized distance of the fragment along the line.)

The value of an associated datum f for the fragment, whether it be a shader output or the clip w coordinate, must be determined using perspective interpolation:

\[f = {{ (1-t) {f_a / w_a} + t { f_b / w_b} } \over {(1-t) / w_a + t / w_b }}\]

where f_a and f_b are the data associated with the starting and ending endpoints of the segment, respectively; w_a and w_b are the clip w coordinates of the starting and ending endpoints of the segments, respectively.

Depth values for lines must be determined using linear interpolation:

: z = (1 - t) z_a + t z_b

where z_a and z_b are the depth values of the starting and ending endpoints of the segment, respectively.

The NoPerspective and Flat interpolation decorations can be used with fragment shader inputs to declare how they are interpolated. When neither decoration is applied, perspective interpolation is performed as described above. When the NoPerspective decoration is used, linear interpolation is performed in the same fashion as for depth values, as described above. When the Flat decoration is used, no interpolation is performed, and outputs are taken from the corresponding input value of the provoking vertex corresponding to that primitive.

When the fragmentShaderBarycentric feature is enabled, the PerVertexNV interpolation decoration can also be used with fragment shader inputs which indicate that the decorated inputs are not interpolated and can only be accessed using an extra array dimension, where the extra index identifies one of the vertices of the primitive that produced the fragment.

The above description documents the preferred method of line rasterization, and must be used when the implementation advertises the strictLines limit in VkPhysicalDeviceLimits as VK_TRUE.

When strictLines is VK_FALSE, the edges of the lines are generated as a parallelogram surrounding the original line. The major axis is chosen by noting the axis in which there is the greatest distance between the line start and end points. If the difference is equal in both directions then the X axis is chosen as the major axis. Edges 2 and 3 are aligned to the minor axis and are centered on the endpoints of the line as in Non strict lines, and each is lineWidth long. Edges 0 and 1 are parallel to the line and connect the endpoints of edges 2 and 3. Coverage bits that correspond to sample points that intersect the parallelogram are 1, other coverage bits are 0.

Samples that fall exactly on the edge of the parallelogram follow the polygon rasterization rules.

Interpolation occurs as if the parallelogram was decomposed into two triangles where each pair of vertices at each end of the line has identical attributes.

Figure 17. Non strict lines

26.10.2. Bresenham Line Segment Rasterization

If lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT, then the following rules replace the line rasterization rules defined in Basic Line Segment Rasterization.

Line segment rasterization begins by characterizing the segment as either x-major or y-major. x-major line segments have slope in the closed interval [-1,1]; all other line segments are y-major (slope is determined by the segment’s endpoints). We specify rasterization only for x-major segments except in cases where the modifications for y-major segments are not self-evident.

Ideally, Vulkan uses a diamond-exit rule to determine those fragments that are produced by rasterizing a line segment. For each fragment f with center at framebuffer coordinates x_f and y_f, define a diamond-shaped region that is the intersection of four half planes:

\[ R_f = \{ (x,y) \mid | x - x_f | + | y - y_f | < \frac{1}{2} \}\]

Essentially, a line segment starting at p_a and ending at p_b produces those fragments f for which the segment intersects R_f, except if p_b is contained in R_f.

Figure 18. Visualization of Bresenham’s algorithm

To avoid difficulties when an endpoint lies on a boundary of R_f we (in principle) perturb the supplied endpoints by a tiny amount. Let p_a and p_b have framebuffer coordinates (x_a, y_a) and (x_b, y_b), respectively. Obtain the perturbed endpoints p_a' given by (x_a, y_a) - (ε, ε²) and p_b' given by (x_b, y_b) - (ε, ε²). Rasterizing the line segment starting at p_a and ending at p_b produces those fragments f for which the segment starting at p_a' and ending on p_b' intersects R_f, except if p_b' is contained in R_f. ε is chosen to be so small that rasterizing the line segment produces the same fragments when δ is substituted for ε for any 0 < δ ≤ ε.

When p_a and p_b lie on fragment centers, this characterization of fragments reduces to Bresenham’s algorithm with one modification: lines produced in this description are "half-open," meaning that the final fragment (corresponding to p_b) is not drawn. This means that when rasterizing a series of connected line segments, shared endpoints will be produced only once rather than twice (as would occur with Bresenham’s algorithm).

Implementations may use other line segment rasterization algorithms, subject to the following rules:

The coordinates of a fragment produced by the algorithm must not deviate by more than one unit in either x or y framebuffer coordinates from a corresponding fragment produced by the diamond-exit rule.
The total number of fragments produced by the algorithm must not differ from that produced by the diamond-exit rule by no more than one.
For an x-major line, two fragments that lie in the same framebuffer-coordinate column must not be produced (for a y-major line, two fragments that lie in the same framebuffer-coordinate row must not be produced).
If two line segments share a common endpoint, and both segments are either x-major (both left-to-right or both right-to-left) or y-major (both bottom-to-top or both top-to-bottom), then rasterizing both segments must not produce duplicate fragments. Fragments also must not be omitted so as to interrupt continuity of the connected segments.

The actual width w of VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT lines is determined by rounding the line width to the nearest integer, clamping it to the implementation-dependent lineWidthRange (with both values rounded to the nearest integer), then clamping it to be no less than 1.

VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT line segments of width other than one are rasterized by offsetting them in the minor direction (for an x-major line, the minor direction is y, and for a y-major line, the minor direction is x) and producing a row or column of fragments in the minor direction. If the line segment has endpoints given by (x₀, y₀) and (x₁, y₁) in framebuffer coordinates, the segment with endpoints \((x_0, y_0 - \frac{w-1}{2})\) and \((x_1, y_1 - \frac{w-1}{2})\) is rasterized, but instead of a single fragment, a column of fragments of height w (a row of fragments of length w for a y-major segment) is produced at each x (y for y-major) location. The lowest fragment of this column is the fragment that would be produced by rasterizing the segment of width 1 with the modified coordinates.

The preferred method of attribute interpolation for a wide line is to generate the same attribute values for all fragments in the row or column described above, as if the adjusted line were used for interpolation and those values replicated to the other fragments, except for FragCoord which is interpolated as usual. Implementations may instead interpolate each fragment according to the formula in Basic Line Segment Rasterization, using the original line segment endpoints.

When VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT lines are being rasterized, sample locations may all be treated as being at the pixel center (this may affect attribute and depth interpolation).

26.10.3. Line Stipple

If the stippledLineEnable member of VkPipelineRasterizationLineStateCreateInfoEXT is VK_TRUE, then lines are rasterized with a line stipple determined by lineStippleFactor and lineStipplePattern. lineStipplePattern is an unsigned 16-bit integer that determines which fragments are to be drawn or discarded when the line is rasterized. lineStippleFactor is a count that is used to modify the effective line stipple by causing each bit in lineStipplePattern to be used lineStippleFactor times.

Line stippling discards certain fragments that are produced by rasterization. The masking is achieved using three parameters: the 16-bit line stipple pattern p, the line stipple factor r, and an integer stipple counter s. Let

\[ b = \lfloor \frac{s}{r} \rfloor \bmod 16\]

Then a fragment is produced if the b’th bit of p is 1, and discarded otherwise. The bits of p are numbered with 0 being the least significant and 15 being the most significant.

The initial value of s is zero. For VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT lines, s is incremented after production of each fragment of a line segment (fragments are produced in order, beginning at the starting point and working towards the ending point). For VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT and VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT lines, the rectangular region is subdivided into adjacent unit-length rectangles, and s is incremented once for each rectangle. Rectangles with a value of s such that the b’th bit of p is zero are discarded. If the last rectangle in a line segment is shorter than unit-length, then the remainder may carry over to the next line segment in the line strip using the same value of s (this is the preferred behavior, for the stipple pattern to appear more consistent through the strip).

s is reset to 0 at the start of each strip (for line strips), and before every line segment in a group of independent segments.

If the line segment has been clipped, then the value of s at the beginning of the line segment is implementation-dependent.

The line stipple factor and pattern are specified by the VkPipelineRasterizationLineStateCreateInfoEXT::lineStippleFactor and VkPipelineRasterizationLineStateCreateInfoEXT::lineStipplePattern members of the currently active pipeline, if the pipeline was not created with VK_DYNAMIC_STATE_LINE_STIPPLE_EXT enabled.

Otherwise, the line stipple factor and pattern are set by calling vkCmdSetLineStippleEXT:

void vkCmdSetLineStippleEXT(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    lineStippleFactor,
    uint16_t                                    lineStipplePattern);

commandBuffer is the command buffer into which the command will be recorded.
lineStippleFactor is the repeat factor used in stippled line rasterization.
lineStipplePattern is the bit pattern used in stippled line rasterization.

Valid Usage

VUID-vkCmdSetLineStippleEXT-lineStippleFactor-02776
lineStippleFactor must be in the range [1,256]

Valid Usage (Implicit)

VUID-vkCmdSetLineStippleEXT-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetLineStippleEXT-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetLineStippleEXT-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

26.10.4. Smooth Lines

If the lineRasterizationMode member of VkPipelineRasterizationLineStateCreateInfoEXT is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT, then lines are considered to be rectangles using the same geometry as for VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT lines. The rules for determining which pixels are covered are implementation-dependent, and may include nearby pixels where no sample locations are covered or where the rectangle doesn’t intersect the pixel at all. For each pixel that is considered covered, the fragment computes a coverage value that approximates the area of the intersection of the rectangle with the pixel square, and this coverage value is multiplied into the color location 0’s alpha value after fragment shading, as described in Multisample Coverage.

Note

The details of the rasterization rules and area calculation are left intentionally vague, to allow implementations to generate coverage and values that are aesthetically pleasing.

26.11. Polygons

A polygon results from the decomposition of a triangle strip, triangle fan or a series of independent triangles. Like points and line segments, polygon rasterization is controlled by several variables in the VkPipelineRasterizationStateCreateInfo structure.

26.11.1. Basic Polygon Rasterization

The first step of polygon rasterization is to determine whether the triangle is back-facing or front-facing. This determination is made based on the sign of the (clipped or unclipped) polygon’s area computed in framebuffer coordinates. One way to compute this area is:

\[a = -{1 \over 2}\sum_{i=0}^{n-1} x_f^i y_f^{i \oplus 1} - x_f^{i \oplus 1} y_f^i\]

where \(x_f^i\) and \(y_f^i\) are the x and y framebuffer coordinates of the ith vertex of the n-vertex polygon (vertices are numbered starting at zero for the purposes of this computation) and i ⊕ 1 is (i + 1) mod n.

The interpretation of the sign of a is determined by the VkPipelineRasterizationStateCreateInfo::frontFace property of the currently active pipeline. Possible values are:

typedef enum VkFrontFace {
    VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
    VK_FRONT_FACE_CLOCKWISE = 1,
    VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
} VkFrontFace;

VK_FRONT_FACE_COUNTER_CLOCKWISE specifies that a triangle with positive area is considered front-facing.
VK_FRONT_FACE_CLOCKWISE specifies that a triangle with negative area is considered front-facing.

Any triangle which is not front-facing is back-facing, including zero-area triangles.

Once the orientation of triangles is determined, they are culled according to the VkPipelineRasterizationStateCreateInfo::cullMode property of the currently active pipeline. Possible values are:

typedef enum VkCullModeFlagBits {
    VK_CULL_MODE_NONE = 0,
    VK_CULL_MODE_FRONT_BIT = 0x00000001,
    VK_CULL_MODE_BACK_BIT = 0x00000002,
    VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
    VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkCullModeFlagBits;

VK_CULL_MODE_NONE specifies that no triangles are discarded
VK_CULL_MODE_FRONT_BIT specifies that front-facing triangles are discarded
VK_CULL_MODE_BACK_BIT specifies that back-facing triangles are discarded
VK_CULL_MODE_FRONT_AND_BACK specifies that all triangles are discarded.

Following culling, fragments are produced for any triangles which have not been discarded.

typedef VkFlags VkCullModeFlags;

VkCullModeFlags is a bitmask type for setting a mask of zero or more VkCullModeFlagBits.

The rule for determining which fragments are produced by polygon rasterization is called point sampling. The two-dimensional projection obtained by taking the x and y framebuffer coordinates of the polygon’s vertices is formed. Fragments are produced for any fragment area groups of pixels for which any sample points lie inside of this polygon. Coverage bits that correspond to sample points that satisfy the point sampling criteria are 1, other coverage bits are 0. Special treatment is given to a sample whose sample location lies on a polygon edge. In such a case, if two polygons lie on either side of a common edge (with identical endpoints) on which a sample point lies, then exactly one of the polygons must result in a covered sample for that fragment during rasterization. As for the data associated with each fragment produced by rasterizing a polygon, we begin by specifying how these values are produced for fragments in a triangle. Define barycentric coordinates for a triangle. Barycentric coordinates are a set of three numbers, a, b, and c, each in the range [0,1], with a + b + c = 1. These coordinates uniquely specify any point p within the triangle or on the triangle’s boundary as

: p = a p_a + b p_b + c p_c

where p_a, p_b, and p_c are the vertices of the triangle. a, b, and c are determined by:

\[a = {{\mathrm{A}(p p_b p_c)} \over {\mathrm{A}(p_a p_b p_c)}}, \quad b = {{\mathrm{A}(p p_a p_c)} \over {\mathrm{A}(p_a p_b p_c)}}, \quad c = {{\mathrm{A}(p p_a p_b)} \over {\mathrm{A}(p_a p_b p_c)}},\]

where A(lmn) denotes the area in framebuffer coordinates of the triangle with vertices l, m, and n.

Denote an associated datum at p_a, p_b, or p_c as f_a, f_b, or f_c, respectively.

The value of an associated datum f for a fragment produced by rasterizing a triangle, whether it be a shader output or the clip w coordinate, must be determined using perspective interpolation:

\[f = { a {f_a / w_a} + b {f_b / w_b} + c {f_c / w_c} } \over { {a / w_a} + {b / w_b} + {c / w_c} }\]

where w_a, w_b, and w_c are the clip w coordinates of p_a, p_b, and p_c, respectively. a, b, and c are the barycentric coordinates of the location at which the data are produced - this must be the location of the fragment center or the location of a sample. When rasterizationSamples is VK_SAMPLE_COUNT_1_BIT, the fragment center must be used.

Depth values for triangles must be determined using linear interpolation:

: z = a z_a + b z_b + c z_c

where z_a, z_b, and z_c are the depth values of p_a, p_b, and p_c, respectively.

When the VK_AMD_shader_explicit_vertex_parameter device extension is enabled the CustomInterpAMD interpolation decoration can also be used with fragment shader inputs which indicate that the decorated inputs can only be accessed by the extended instruction InterpolateAtVertexAMD and allows accessing the value of the inputs for individual vertices of the primitive.

For a polygon with more than three edges, such as are produced by clipping a triangle, a convex combination of the values of the datum at the polygon’s vertices must be used to obtain the value assigned to each fragment produced by the rasterization algorithm. That is, it must be the case that at every fragment

\[f = \sum_{i=1}^{n} a_i f_i\]

where n is the number of vertices in the polygon and f_i is the value of f at vertex i. For each i, 0 ≤ a_i ≤ 1 and \(\sum_{i=1}^{n}a_i = 1\). The values of a_i may differ from fragment to fragment, but at vertex i, a_i = 1 and a_j = 0 for j ≠ i.

Note

One algorithm that achieves the required behavior is to triangulate a polygon (without adding any vertices) and then treat each triangle individually as already discussed. A scan-line rasterizer that linearly interpolates data along each edge and then linearly interpolates data across each horizontal span from edge to edge also satisfies the restrictions (in this case, the numerator and denominator of equation [triangle_perspective_interpolation] are iterated independently and a division performed for each fragment).

26.11.2. Polygon Mode

Possible values of the VkPipelineRasterizationStateCreateInfo::polygonMode property of the currently active pipeline, specifying the method of rasterization for polygons, are:

typedef enum VkPolygonMode {
    VK_POLYGON_MODE_FILL = 0,
    VK_POLYGON_MODE_LINE = 1,
    VK_POLYGON_MODE_POINT = 2,
    VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000,
    VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
} VkPolygonMode;

VK_POLYGON_MODE_POINT specifies that polygon vertices are drawn as points.
VK_POLYGON_MODE_LINE specifies that polygon edges are drawn as line segments.
VK_POLYGON_MODE_FILL specifies that polygons are rendered using the polygon rasterization rules in this section.
VK_POLYGON_MODE_FILL_RECTANGLE_NV specifies that polygons are rendered using polygon rasterization rules, modified to consider a sample within the primitive if the sample location is inside the axis-aligned bounding box of the triangle after projection. Note that the barycentric weights used in attribute interpolation can extend outside the range [0,1] when these primitives are shaded. Special treatment is given to a sample position on the boundary edge of the bounding box. In such a case, if two rectangles lie on either side of a common edge (with identical endpoints) on which a sample position lies, then exactly one of the triangles must produce a fragment that covers that sample during rasterization.

Polygons rendered in VK_POLYGON_MODE_FILL_RECTANGLE_NV mode may be clipped by the frustum or by user clip planes. If clipping is applied, the triangle is culled rather than clipped.

Area calculation and facingness are determined for VK_POLYGON_MODE_FILL_RECTANGLE_NV mode using the triangle’s vertices.

These modes affect only the final rasterization of polygons: in particular, a polygon’s vertices are shaded and the polygon is clipped and possibly culled before these modes are applied.

26.11.3. Depth Bias

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.

void vkCmdSetDepthBias(
    VkCommandBuffer                             commandBuffer,
    float                                       depthBiasConstantFactor,
    float                                       depthBiasClamp,
    float                                       depthBiasSlopeFactor);

commandBuffer is the command buffer into which the command will be recorded.
depthBiasConstantFactor is a scalar factor controlling the constant depth value added to each fragment.
depthBiasClamp is the maximum (or minimum) depth bias of a fragment.
depthBiasSlopeFactor is a scalar factor applied to a fragment’s slope in depth bias calculations.

If depthBiasEnable is VK_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 m of a triangle is

\[m = \sqrt{ \left({{\partial z_f} \over {\partial x_f}}\right)^2 + \left({{\partial z_f} \over {\partial y_f}}\right)^2}\]

where (x_f, y_f, z_f) is a point on the triangle. m may be approximated as

\[m = \max\left( \left| { {\partial z_f} \over {\partial x_f} } \right|, \left| { {\partial z_f} \over {\partial y_f} } \right| \right).\]

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 z_f 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 = 2^e-n

If a triangle is rasterized using the VK_POLYGON_MODE_FILL_RECTANGLE_NV polygon mode, then this minimum resolvable difference may not be resolvable for samples outside of the triangle, where the depth is extrapolated.

If no depth buffer is present, r is undefined.

The bias value o for a polygon is

\[\begin{aligned} o &= \mathrm{dbclamp}( m \times \mathtt{depthBiasSlopeFactor} + r \times \mathtt{depthBiasConstantFactor} ) \\ \text{where} &\quad \mathrm{dbclamp}(x) = \begin{cases} x & \mathtt{depthBiasClamp} = 0 \ \text{or}\ \texttt{NaN} \\ \min(x, \mathtt{depthBiasClamp}) & \mathtt{depthBiasClamp} > 0 \\ \max(x, \mathtt{depthBiasClamp}) & \mathtt{depthBiasClamp} < 0 \\ \end{cases} \end{aligned}\]

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. Unless the VK_EXT_depth_range_unrestricted extension is enabled, fragment depth values are clamped even when the depth buffer uses a floating-point representation.

Valid Usage

VUID-vkCmdSetDepthBias-depthBiasClamp-00790
If the depth bias clamping feature is not enabled, depthBiasClamp must be 0.0

Valid Usage (Implicit)

VUID-vkCmdSetDepthBias-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetDepthBias-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetDepthBias-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

26.11.4. Conservative Rasterization

Polygon rasterization can be made conservative by setting conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT or VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT in VkPipelineRasterizationConservativeStateCreateInfoEXT. The VkPipelineRasterizationConservativeStateCreateInfoEXT state is set by adding this structure to the pNext chain of a VkPipelineRasterizationStateCreateInfo structure when creating the graphics pipeline. Enabling these modes also affects line and point rasterization if the implementation sets VkPhysicalDeviceConservativeRasterizationPropertiesEXT::conservativePointAndLineRasterization to VK_TRUE.

VkPipelineRasterizationConservativeStateCreateInfoEXT is defined as:

typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT {
    VkStructureType                                           sType;
    const void*                                               pNext;
    VkPipelineRasterizationConservativeStateCreateFlagsEXT    flags;
    VkConservativeRasterizationModeEXT                        conservativeRasterizationMode;
    float                                                     extraPrimitiveOverestimationSize;
} VkPipelineRasterizationConservativeStateCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
conservativeRasterizationMode is the conservative rasterization mode to use.
extraPrimitiveOverestimationSize is the extra size in pixels to increase the generating primitive during conservative rasterization at each of its edges in X and Y equally in screen space beyond the base overestimation specified in VkPhysicalDeviceConservativeRasterizationPropertiesEXT::primitiveOverestimationSize.

Valid Usage

VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-extraPrimitiveOverestimationSize-01769
extraPrimitiveOverestimationSize must be in the range of 0.0 to VkPhysicalDeviceConservativeRasterizationPropertiesEXT::maxExtraPrimitiveOverestimationSize inclusive

Valid Usage (Implicit)

VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT
VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-flags-zerobitmask
flags must be 0
VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-conservativeRasterizationMode-parameter
conservativeRasterizationMode must be a valid VkConservativeRasterizationModeEXT value

typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT;

VkPipelineRasterizationConservativeStateCreateFlagsEXT is a bitmask type for setting a mask, but is currently reserved for future use.

Possible values of VkPipelineRasterizationConservativeStateCreateInfoEXT::conservativeRasterizationMode, specifying the conservative rasterization mode are:

typedef enum VkConservativeRasterizationModeEXT {
    VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0,
    VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1,
    VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2,
    VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
} VkConservativeRasterizationModeEXT;

VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT specifies that conservative rasterization is disabled and rasterization proceeds as normal.
VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT specifies that conservative rasterization is enabled in overestimation mode.
VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT specifies that conservative rasterization is enabled in underestimation mode.

When overestimate conservative rasterization is enabled, rather than evaluating coverage at individual sample locations, a determination is made of whether any portion of the pixel (including its edges and corners) is covered by the primitive. If any portion of the pixel is covered, then all bits of the coverage sample mask for the fragment corresponding to that pixel are enabled. If the render pass has a fragment density map attachment and any bit of the coverage sample mask for the fragment is enabled, then all bits of the coverage sample mask for the fragment are enabled.

If the implementation supports VkPhysicalDeviceConservativeRasterizationPropertiesEXT::conservativeRasterizationPostDepthCoverage and the PostDepthCoverage execution mode is specified the SampleMask built-in input variable will reflect the coverage after the early per-fragment depth and stencil tests are applied.

For the purposes of evaluating which pixels are covered by the primitive, implementations can increase the size of the primitive by up to VkPhysicalDeviceConservativeRasterizationPropertiesEXT::primitiveOverestimationSize pixels at each of the primitive edges. This may increase the number of fragments generated by this primitive and represents an overestimation of the pixel coverage.

This overestimation size can be increased further by setting the extraPrimitiveOverestimationSize value above 0.0 in steps of VkPhysicalDeviceConservativeRasterizationPropertiesEXT::extraPrimitiveOverestimationSizeGranularity up to and including VkPhysicalDeviceConservativeRasterizationPropertiesEXT::extraPrimitiveOverestimationSize. This will: further increase the number of fragments generated by this primitive.

The actual precision of the overestimation size used for conservative rasterization may vary between implementations and produce results that only approximate the primitiveOverestimationSize and extraPrimitiveOverestimationSizeGranularity properties. Implementations may especially vary these approximations when the render pass has a fragment density map and the fragment area covers multiple pixels.

For triangles if VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT is enabled, fragments will be generated if the primitive area covers any portion of any pixel inside the fragment area, including their edges or corners. The tie-breaking rule described in Basic Polygon Rasterization does not apply during conservative rasterization and coverage is set for all fragments generated from shared edges of polygons. Degenerate triangles that evaluate to zero area after rasterization, even for pixels containing a vertex or edge of the zero-area polygon, will be culled if VkPhysicalDeviceConservativeRasterizationPropertiesEXT::degenerateTrianglesRasterized is VK_FALSE or will generate fragments if degenerateTrianglesRasterized is VK_TRUE. The fragment input values for these degenerate triangles take their attribute and depth values from the provoking vertex. Degenerate triangles are considered backfacing and the application can enable backface culling if desired. Triangles that are zero area before rasterization may be culled regardless.

For lines if VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT is enabled, and the implementation sets VkPhysicalDeviceConservativeRasterizationPropertiesEXT::conservativePointAndLineRasterization to VK_TRUE, fragments will be generated if the line covers any portion of any pixel inside the fragment area, including their edges or corners. Degenerate lines that evaluate to zero length after rasterization will be culled if VkPhysicalDeviceConservativeRasterizationPropertiesEXT::degenerateLinesRasterized is VK_FALSE or will generate fragments if degenerateLinesRasterized is VK_TRUE. The fragments input values for these degenerate lines take their attribute and depth values from the provoking vertex. Lines that are zero length before rasterization may be culled regardless.

For points if VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT is enabled, and the implementation sets VkPhysicalDeviceConservativeRasterizationPropertiesEXT::conservativePointAndLineRasterization to VK_TRUE, fragments will be generated if the point square covers any portion of any pixel inside the fragment area, including their edges or corners.

When underestimate conservative rasterization is enabled, rather than evaluating coverage at individual sample locations, a determination is made of whether all of the pixel (including its edges and corners) is covered by the primitive. If the entire pixel is covered, then a fragment is generated with all bits of its coverage sample mask corresponding to the pixel enabled, otherwise the pixel is not considered covered even if some portion of the pixel is covered. The fragment is discarded if no pixels inside the fragment area are considered covered. If the render pass has a fragment density map attachment and any pixel inside the fragment area is not considered covered, then the fragment is discarded even if some pixels are considered covered.

For triangles, if VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT is enabled, fragments will only be generated if any pixel inside the fragment area is fully covered by the generating primitive, including its edges and corners.

For lines, if VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT is enabled, fragments will be generated if any pixel inside the fragment area, including its edges and corners, are entirely covered by the line.

For points, if VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT is enabled, fragments will only be generated if the point square covers the entirety of any pixel square inside the fragment area, including its edges or corners.

If the render pass has a fragment density map and VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT is enabled, fragments will only be generated if the entirety of all pixels inside the fragment area are covered by the generating primitive, line, or point.

For both overestimate and underestimate conservative rasterization modes a fragment has all of its pixel squares fully covered by the generating primitive must set FullyCoveredEXT to VK_TRUE if the implementation enables the VkPhysicalDeviceConservativeRasterizationPropertiesEXT::fullyCoveredFragmentShaderInputVariable feature.

When the use of a shading rate image results in fragments covering multiple pixels, coverage for conservative rasterization is still evaluated on a per-pixel basis and may result in fragments with partial coverage. For fragment shader inputs decorated with FullyCoveredEXT, a fragment is considered fully covered if and only if all pixels in the fragment are fully covered by the generating primitive.

27. Fragment Operations

Fragment operations execute on a per-fragment or per-sample basis, affecting whether or how a fragment or sample is written to the framebuffer. Some operations execute before fragment shading, and others after. Fragment operations always adhere to rasterization order.

27.1. Early Per-Fragment Tests

Once fragments are produced by rasterization, a number of per-fragment operations are performed prior to fragment shader execution. If a fragment is discarded during any of these operations, it will not be processed by any subsequent stage, including fragment shader execution.

The scissor test, exclusive scissor test, and sample mask generation are always performed during early fragment tests.

Fragment operations are performed in the following order:

the discard rectangles test (see Discard Rectangles Test)
the scissor test (see Scissor Test)
the exclusive scissor test (see Exclusive Scissor Test)
multisample fragment operations (see Sample Mask)

If early per-fragment operations are enabled by the fragment shader, these operations are also performed:

Depth bounds test
Stencil test
Depth test
Representative fragment test
Sample counting for occlusion queries

If post-depth coverage operation is enabled by the fragment shader, the SampleMask coverage is determined after the early stencil and depth tests.

27.2. Discard Rectangles Test

The discard rectangles test determines if fragment’s framebuffer coordinates (x_f,y_f) are inclusive or exclusive to a set of discard-space rectangles. The discard rectangles are set with the VkPipelineDiscardRectangleStateCreateInfoEXT pipeline state, which is defined as:

typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT {
    VkStructureType                                  sType;
    const void*                                      pNext;
    VkPipelineDiscardRectangleStateCreateFlagsEXT    flags;
    VkDiscardRectangleModeEXT                        discardRectangleMode;
    uint32_t                                         discardRectangleCount;
    const VkRect2D*                                  pDiscardRectangles;
} VkPipelineDiscardRectangleStateCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
discardRectangleMode is the mode used to determine whether fragments that lie within the discard rectangle are discarded or not.
discardRectangleCount is the number of discard rectangles used by the pipeline.
pDiscardRectangles is a pointer to an array of VkRect2D structures, defining the discard rectangles. If the discard rectangle state is dynamic, this member is ignored.

Valid Usage

VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleCount-00582
discardRectangleCount must be between 0 and VkPhysicalDeviceDiscardRectanglePropertiesEXT::maxDiscardRectangles, inclusive

Valid Usage (Implicit)

VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT
VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-flags-zerobitmask
flags must be 0
VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleMode-parameter
discardRectangleMode must be a valid VkDiscardRectangleModeEXT value

typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;

VkPipelineDiscardRectangleStateCreateFlagsEXT is a bitmask type for setting a mask, but is currently reserved for future use.

The VkPipelineDiscardRectangleStateCreateInfoEXT state is set by adding this structure to the pNext chain of a VkGraphicsPipelineCreateInfo structure and setting the graphics pipeline state with vkCreateGraphicsPipelines.

If the bound pipeline state object was not created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT dynamic state enabled, discard rectangles are specified using the pDiscardRectangles member of VkPipelineDiscardRectangleStateCreateInfoEXT linked to the pipeline state object.

If the pipeline state object was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT dynamic state enabled, the discard rectangles are dynamically set and changed with the command:

void vkCmdSetDiscardRectangleEXT(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    firstDiscardRectangle,
    uint32_t                                    discardRectangleCount,
    const VkRect2D*                             pDiscardRectangles);

commandBuffer is the command buffer into which the command will be recorded.
firstDiscardRectangle is the index of the first discard rectangle whose state is updated by the command.
discardRectangleCount is the number of discard rectangles whose state are updated by the command.
pDiscardRectangles is a pointer to an array of VkRect2D structures specifying discard rectangles.

The discard rectangle taken from element i of pDiscardRectangles replace the current state for the discard rectangle index firstDiscardRectangle + i, for i in [0, discardRectangleCount).

Valid Usage

VUID-vkCmdSetDiscardRectangleEXT-firstDiscardRectangle-00585
The sum of firstDiscardRectangle and discardRectangleCount must be less than or equal to VkPhysicalDeviceDiscardRectanglePropertiesEXT::maxDiscardRectangles
VUID-vkCmdSetDiscardRectangleEXT-x-00587
The x and y member of offset in each VkRect2D element of pDiscardRectangles must be greater than or equal to 0
VUID-vkCmdSetDiscardRectangleEXT-offset-00588
Evaluation of (offset.x + extent.width) in each VkRect2D element of pDiscardRectangles must not cause a signed integer addition overflow
VUID-vkCmdSetDiscardRectangleEXT-offset-00589
Evaluation of (offset.y + extent.height) in each VkRect2D element of pDiscardRectangles must not cause a signed integer addition overflow

Valid Usage (Implicit)

VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetDiscardRectangleEXT-pDiscardRectangles-parameter
pDiscardRectangles must be a valid pointer to an array of discardRectangleCount VkRect2D structures
VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdSetDiscardRectangleEXT-discardRectangleCount-arraylength
discardRectangleCount must be greater than 0

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

The VkOffset2D::x and VkOffset2D::y values of the discard rectangle VkRect2D specify the upper-left origin of the discard rectangle box. The lower-right corner of the discard rectangle box is specified as the VkExtent2D::width and VkExtent2D::height from the upper-left origin.

If offset.x ≤ x_f < offset.x + extent.width and offset.y ≤ y_f < offset.y + extent.height for the selected discard rectangle, then the fragment is within the discard rectangle box. When the discard rectangle mode is VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT a fragment within at least one of the active discard rectangle boxes passes the discard rectangle test; otherwise the fragment fails the discard rectangle test and is discarded. When the discard rectangle mode is VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT a fragment within at least one of the active discard rectangle boxes fails the discard rectangle test, and the fragment is discarded; otherwise the fragment passes the discard rectangles test. The discard rectangles test only applies to drawing commands, not to other commands like clears or copies.

Possible values of VkPipelineDiscardRectangleStateCreateInfoEXT::discardRectangleMode, specifying the behavior of the discard rectangle test, are:

typedef enum VkDiscardRectangleModeEXT {
    VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0,
    VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1,
    VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
} VkDiscardRectangleModeEXT;

VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT specifies that a fragment within any discard rectangle satisfies the test.
VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT specifies that a fragment not within any of the discard rectangles satisfies the test.

When the use of a shading rate image results in a fragment covering multiple pixels, the discard rectangle test is performed independently for each pixel in the fragment. If a pixel covered by a fragment fails the discard rectangle test, all samples in the fragment associated with that pixel are treated as not covered. If the discard rectangle test results in a fragment with no samples covered, that fragment is discarded.

27.3. Scissor Test

The scissor test determines if a fragment’s framebuffer coordinates (x_f,y_f) lie within the scissor rectangle corresponding to the viewport index (see Controlling the Viewport) used by the primitive that generated the fragment. If the pipeline state object is created without VK_DYNAMIC_STATE_SCISSOR enabled then the scissor rectangles are set by the VkPipelineViewportStateCreateInfo state of the pipeline state object. Otherwise, to dynamically set the scissor rectangles call:

void vkCmdSetScissor(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    firstScissor,
    uint32_t                                    scissorCount,
    const VkRect2D*                             pScissors);

commandBuffer is the command buffer into which the command will be recorded.
firstScissor is the index of the first scissor whose state is updated by the command.
scissorCount is the number of scissors whose rectangles are updated by the command.
pScissors is a pointer to an array of VkRect2D structures defining 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.

Valid Usage

VUID-vkCmdSetScissor-firstScissor-00591
firstScissor must be less than VkPhysicalDeviceLimits::maxViewports
VUID-vkCmdSetScissor-firstScissor-00592
The sum of firstScissor and scissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive
VUID-vkCmdSetScissor-firstScissor-00593
If the multiple viewports feature is not enabled, firstScissor must be 0
VUID-vkCmdSetScissor-scissorCount-00594
If the multiple viewports feature is not enabled, scissorCount must be 1
VUID-vkCmdSetScissor-x-00595
The x and y members of offset member of any element of pScissors must be greater than or equal to 0
VUID-vkCmdSetScissor-offset-00596
Evaluation of (offset.x + extent.width) must not cause a signed integer addition overflow for any element of pScissors
VUID-vkCmdSetScissor-offset-00597
Evaluation of (offset.y + extent.height) must not cause a signed integer addition overflow for any element of pScissors

Valid Usage (Implicit)

VUID-vkCmdSetScissor-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetScissor-pScissors-parameter
pScissors must be a valid pointer to an array of scissorCount VkRect2D structures
VUID-vkCmdSetScissor-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetScissor-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdSetScissor-scissorCount-arraylength
scissorCount must be greater than 0

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

If offset.x ≤ x_f < offset.x + extent.width and offset.y ≤ y_f < 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 (see Controlling the Viewport). The scissor rectangles test only applies 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.

When the use of a shading rate image results in a fragment covering multiple pixels, the scissor test is performed independently for each pixel in the fragment. If a pixel covered by a fragment fails the scissor test, all samples in the fragment associated with that pixel are treated as not covered. If the scissor test results in a fragment with no samples covered, that fragment is discarded.

27.4. Exclusive Scissor Test

The exclusive scissor test determines if a pixel’s framebuffer coordinates (x_f,y_f) lie outside the exclusive scissor rectangle corresponding to the viewport index (see Controlling the Viewport) used by the primitive that generated the fragment. The exclusive scissor test behaves identically to the scissor test, except that it passes only if the pixel is outside the rectangle instead of passing if the pixel is inside the rectangle.

If the pNext chain of VkPipelineViewportStateCreateInfo includes a VkPipelineViewportExclusiveScissorStateCreateInfoNV structure, then that structure includes parameters that affect the exclusive scissor test.

The VkPipelineViewportExclusiveScissorStateCreateInfoNV structure is defined as:

typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           exclusiveScissorCount;
    const VkRect2D*    pExclusiveScissors;
} VkPipelineViewportExclusiveScissorStateCreateInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
exclusiveScissorCount is the number of exclusive scissor rectangles used by the pipeline.
pExclusiveScissors is a pointer to an array of VkRect2D structures defining exclusive scissor rectangles. If the exclusive scissor state is dynamic, this member is ignored.

If this structure is not present, exclusiveScissorCount is considered to be 0 and the exclusive scissor test is disabled.

Valid Usage

VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02027
If the multiple viewports feature is not enabled, exclusiveScissorCount must be 0 or 1
VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02028
exclusiveScissorCount must be less than or equal to VkPhysicalDeviceLimits::maxViewports
VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02029
exclusiveScissorCount must be 0 or identical to the viewportCount member of VkPipelineViewportStateCreateInfo
VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-pDynamicStates-02030
If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV and exclusiveScissorCount is not 0, pExclusiveScissors must be a valid pointer to an array of exclusiveScissorCount VkRect2D structures

Valid Usage (Implicit)

VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV
VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-pExclusiveScissors-parameter
If exclusiveScissorCount is not 0, and pExclusiveScissors is not NULL, pExclusiveScissors must be a valid pointer to an array of exclusiveScissorCount VkRect2D structures

If the pipeline state object is created with VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV enabled, then the exclusive scissor rectangles are set by:

void vkCmdSetExclusiveScissorNV(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    firstExclusiveScissor,
    uint32_t                                    exclusiveScissorCount,
    const VkRect2D*                             pExclusiveScissors);

commandBuffer is the command buffer into which the command will be recorded.
firstExclusiveScissor is the index of the first exclusive scissor rectangle whose state is updated by the command.
exclusiveScissorCount is the number of exclusive scissor rectangles updated by the command.
pExclusiveScissors is a pointer to an array of VkRect2D structures defining exclusive scissor rectangles.

The scissor rectangles taken from element i of pExclusiveScissors replace the current state for the scissor index firstExclusiveScissor + i, for i in [0, exclusiveScissorCount).

Valid Usage

VUID-vkCmdSetExclusiveScissorNV-None-02031
The exclusive scissor feature must be enabled.
VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02033
firstExclusiveScissor must be less than VkPhysicalDeviceLimits::maxViewports
VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02034
The sum of firstExclusiveScissor and exclusiveScissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive
VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02035
If the multiple viewports feature is not enabled, firstExclusiveScissor must be 0
VUID-vkCmdSetExclusiveScissorNV-exclusiveScissorCount-02036
If the multiple viewports feature is not enabled, exclusiveScissorCount must be 1
VUID-vkCmdSetExclusiveScissorNV-x-02037
The x and y members of offset in each member of pExclusiveScissors must be greater than or equal to 0
VUID-vkCmdSetExclusiveScissorNV-offset-02038
Evaluation of (offset.x + extent.width) for each member of pExclusiveScissors must not cause a signed integer addition overflow
VUID-vkCmdSetExclusiveScissorNV-offset-02039
Evaluation of (offset.y + extent.height) for each member of pExclusiveScissors must not cause a signed integer addition overflow

Valid Usage (Implicit)

VUID-vkCmdSetExclusiveScissorNV-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetExclusiveScissorNV-pExclusiveScissors-parameter
pExclusiveScissors must be a valid pointer to an array of exclusiveScissorCount VkRect2D structures
VUID-vkCmdSetExclusiveScissorNV-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetExclusiveScissorNV-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations
VUID-vkCmdSetExclusiveScissorNV-exclusiveScissorCount-arraylength
exclusiveScissorCount must be greater than 0

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

If offset.x ≤ x_f < offset.x + extent.width and offset.y ≤ y_f < offset.y + extent.height for the selected exclusive scissor rectangle, then the exclusive scissor test fails and the fragment is discarded. Otherwise, the exclusive scissor test passes. For points, lines, and polygons, the exclusive scissor rectangle for a primitive is selected in the same manner as the viewport (see Controlling the Viewport). The exclusive scissor test only applies 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 exclusive scissor test still applies as defined above. Rasterization does not produce fragments outside of the framebuffer, so such fragments never have the exclusive scissor test performed on them.

The exclusive scissor test is performed if and only if the current pipeline was created with a non-zero exclusiveScissorCount. Applications can effectively disable the exclusive scissor test for specific viewports by specifying a scissor rectangle with a width or height of zero.

When the use of a shading rate image results in a fragment covering multiple pixels, the exclusive scissor test is performed independently for each pixel in the fragment. If a pixel covered by a fragment fails the exclusive scissor test, all samples in the fragment associated with that pixel are treated as not covered. If the exclusive scissor test results in a fragment with no samples covered, that fragment is discarded.

27.5. Sample Mask

This step modifies fragment coverage values based on the values in the pSampleMask array member of VkPipelineMultisampleStateCreateInfo, as described previously in section Graphics Pipelines.

pSampleMask contains an array of static coverage information that is ANDed with the coverage information generated during rasterization. Bits that are zero disable coverage for the corresponding sample. Bit B of mask word M corresponds to sample 32 × M + B. The array is sized to a length of ⌈ rasterizationSamples / 32 ⌉ words. If pSampleMask is NULL, it is treated as if the mask has all bits enabled, i.e. no coverage is removed from fragments.

The elements of the sample mask array are of type VkSampleMask, each representing 32 bits of coverage information:

typedef uint32_t VkSampleMask;

27.6. Early Fragment Test Mode

The depth bounds test, stencil test, depth test, representative fragment test, and occlusion query sample counting are performed before fragment shading if and only if early fragment tests are enabled by the fragment shader (see Early Fragment Tests). When early per-fragment operations are enabled, these operations are performed prior to fragment shader execution, and the stencil buffer, depth buffer, and occlusion query sample counts will be updated accordingly; these operations will not be performed again after fragment shader execution.

If a pipeline’s fragment shader has early fragment tests disabled, these operations are performed only after fragment program execution, in the order described below. If a pipeline does not contain a fragment shader, these operations are performed only once.

If early fragment tests are enabled, any depth value computed by the fragment shader has no effect. Additionally, the depth test (including depth writes), stencil test (including stencil writes) and sample counting operations are performed even for fragments or samples that would be discarded after fragment shader execution due to per-fragment operations such as alpha-to-coverage tests, or due to the fragment being discarded by the shader itself.

27.7. Late Per-Fragment Tests

After programmable fragment processing, per-fragment operations are performed before blending and color output to the framebuffer.

A fragment is produced by rasterization with framebuffer coordinates of (x_f,y_f) and depth z, as described in Rasterization. The fragment is then modified by programmable fragment processing, which adds associated data as described in Shaders. The fragment is then further modified, and possibly discarded by the late per-fragment operations described in this chapter. Finally, if the fragment was not discarded, it is used to update the framebuffer at the fragment’s framebuffer coordinates for any samples that remain covered.

The depth bounds test, stencil test, and depth test are performed for each sample, rather than just once for each fragment. Stencil and depth operations are performed for a sample only if that sample’s fragment coverage bit is a value of 1 when the fragment executes the corresponding stage of the graphics pipeline. If the corresponding coverage bit is 0, no operations are performed for that sample. Failure of the depth bounds, stencil, or depth test results in termination of the processing of that sample by means of disabling coverage for that sample, rather than discarding of the fragment. If, at any point, a fragment’s coverage becomes zero for all samples, then the fragment is discarded. All operations are performed on the depth and stencil values stored in the depth/stencil attachment of the framebuffer. The contents of the color attachments are not modified at this point.

The depth bounds test, stencil test, depth test, and occlusion query operations described in Depth Bounds Test, Stencil Test, Depth Test, Sample Counting are instead performed prior to fragment processing, as described in Early Fragment Test Mode, if requested by the fragment shader.

27.8. Mixed attachment samples

When the VK_AMD_mixed_attachment_samples extension is enabled, special rules apply to per-fragment operations when the number of samples of the color attachments differs from the number of samples of the depth/stencil attachment used in a subpass.

Let C be the number of color attachment samples and D be the number of depth/stencil attachment samples used by a given subpass.

If C < D then only the first C number of samples are guaranteed to have a corresponding fragment shader invocation and thus a corresponding color output value, unless the fragment shaders produce inputs to the late per-fragment tests (e.g. by outputting to a variable decorated with the FragDepth built-in decoration). Implementations are allowed to produce fragment shader invocations for samples with indices greater than or equal to C but (other than potential side effects) the color outputs of fragment shader invocations corresponding to such samples are discarded.

27.9. Multisample Coverage

If a fragment shader is active and its entry point’s interface includes a built-in output variable decorated with SampleMask and also decorated with OverrideCoverageNV the fragment coverage is replaced with the sample mask bits set in the shader. Otherwise if the built-in output variable decorated with SampleMask is not also decorated with OverrideCoverageNV then the fragment coverage is ANDed with the bits of the sample mask to generate a new fragment coverage value. If such a fragment shader did not assign a value to SampleMask due to flow of control, the value ANDed with the fragment coverage is undefined. If no fragment shader is active, or if the active fragment shader does not include SampleMask in its interface, the fragment coverage is not modified.

Next, the fragment alpha and coverage values are modified based on the line coverage factor if the lineRasterizationMode member of the VkPipelineRasterizationStateCreateInfo structure is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT, and the alphaToCoverageEnable and alphaToOneEnable members of the VkPipelineMultisampleStateCreateInfo structure.

All alpha values in this section refer only to the alpha component of the fragment shader output that has a Location and Index decoration of zero (see the Fragment Output Interface section). If that shader output has an integer or unsigned integer type, then these operations are skipped.

If the lineRasterizationMode member of the VkPipelineRasterizationStateCreateInfo structure is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT and the fragment came from a line segment, then the alpha value is replaced by multiplying it by the coverage factor for the fragment computed during smooth line rasterization.

If alphaToCoverageEnable is enabled, a temporary coverage value with rasterizationSamples bits is generated where each bit is determined by the fragment’s alpha value. The temporary coverage value is then ANDed with the fragment coverage value to generate a new fragment coverage value.

No specific algorithm is specified for converting the alpha value to a temporary coverage mask. It is intended that the number of 1’s in this value be proportional to the alpha value (clamped to [0,1]), with all 1’s corresponding to a value of 1.0 and all 0’s corresponding to 0.0. The algorithm may be different at different framebuffer coordinates.

Note

Using different algorithms at different framebuffer coordinates may help to avoid artifacts caused by regular coverage sample locations.

Next, if alphaToOneEnable is enabled, each alpha value is replaced by the maximum representable alpha value for fixed-point color buffers, or by 1.0 for floating-point buffers. Otherwise, the alpha values are not changed.

27.10. Depth and Stencil Operations

Pipeline state controlling the depth bounds tests, stencil test, and depth test is specified through the members of the VkPipelineDepthStencilStateCreateInfo structure.

The VkPipelineDepthStencilStateCreateInfo structure is defined as:

typedef struct VkPipelineDepthStencilStateCreateInfo {
    VkStructureType                           sType;
    const void*                               pNext;
    VkPipelineDepthStencilStateCreateFlags    flags;
    VkBool32                                  depthTestEnable;
    VkBool32                                  depthWriteEnable;
    VkCompareOp                               depthCompareOp;
    VkBool32                                  depthBoundsTestEnable;
    VkBool32                                  stencilTestEnable;
    VkStencilOpState                          front;
    VkStencilOpState                          back;
    float                                     minDepthBounds;
    float                                     maxDepthBounds;
} VkPipelineDepthStencilStateCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
depthTestEnable controls whether depth testing is enabled.
depthWriteEnable controls whether depth writes are enabled when depthTestEnable is VK_TRUE. Depth writes are always disabled when depthTestEnable is VK_FALSE.
depthCompareOp is the comparison operator used in the depth test.
depthBoundsTestEnable controls whether depth bounds testing is enabled.
stencilTestEnable controls whether stencil testing is enabled.
front and back control the parameters of the stencil test.
minDepthBounds and maxDepthBounds define the range of values used in the depth bounds test.

Valid Usage

VUID-VkPipelineDepthStencilStateCreateInfo-depthBoundsTestEnable-00598
If the depth bounds testing feature is not enabled, depthBoundsTestEnable must be VK_FALSE

Valid Usage (Implicit)

VUID-VkPipelineDepthStencilStateCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
VUID-VkPipelineDepthStencilStateCreateInfo-pNext-pNext
pNext must be NULL
VUID-VkPipelineDepthStencilStateCreateInfo-flags-zerobitmask
flags must be 0
VUID-VkPipelineDepthStencilStateCreateInfo-depthCompareOp-parameter
depthCompareOp must be a valid VkCompareOp value
VUID-VkPipelineDepthStencilStateCreateInfo-front-parameter
front must be a valid VkStencilOpState structure
VUID-VkPipelineDepthStencilStateCreateInfo-back-parameter
back must be a valid VkStencilOpState structure

typedef VkFlags VkPipelineDepthStencilStateCreateFlags;

VkPipelineDepthStencilStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

27.11. Depth Bounds Test

The depth bounds test conditionally disables coverage of a sample based on the outcome of a comparison between the value z_a in the depth attachment at location (x_f,y_f) (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 VK_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:

void vkCmdSetDepthBounds(
    VkCommandBuffer                             commandBuffer,
    float                                       minDepthBounds,
    float                                       maxDepthBounds);

commandBuffer is the command buffer into which the command will be recorded.
minDepthBounds is the lower bound of the range of depth values used in the depth bounds test.
maxDepthBounds is the upper bound of the range.

Valid Usage

VUID-vkCmdSetDepthBounds-minDepthBounds-00600
Unless the VK_EXT_depth_range_unrestricted extension is enabled minDepthBounds must be between 0.0 and 1.0, inclusive
VUID-vkCmdSetDepthBounds-maxDepthBounds-00601
Unless the VK_EXT_depth_range_unrestricted extension is enabled maxDepthBounds must be between 0.0 and 1.0, inclusive

Valid Usage (Implicit)

VUID-vkCmdSetDepthBounds-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetDepthBounds-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetDepthBounds-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

If minDepthBounds ≤ z_a ≤ 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.

27.12. Stencil Test

The stencil test conditionally disables coverage of a sample based on the outcome of a comparison between the stencil value in the depth/stencil attachment at location (x_f,y_f) (for the appropriate sample) and a reference value. The stencil test also updates the value in the stencil attachment, depending on the test state, the stencil value and the stencil write masks. The test is enabled or disabled by the stencilTestEnable member of VkPipelineDepthStencilStateCreateInfo.

When disabled, the stencil test and associated modifications are not made, and the sample’s coverage is not modified.

The stencil test is controlled by the front and back members of VkPipelineDepthStencilStateCreateInfo, which are of type VkStencilOpState.

The VkStencilOpState structure is defined as:

typedef struct VkStencilOpState {
    VkStencilOp    failOp;
    VkStencilOp    passOp;
    VkStencilOp    depthFailOp;
    VkCompareOp    compareOp;
    uint32_t       compareMask;
    uint32_t       writeMask;
    uint32_t       reference;
} VkStencilOpState;

failOp is a VkStencilOp value specifying the action performed on samples that fail the stencil test.
passOp is a VkStencilOp value specifying the action performed on samples that pass both the depth and stencil tests.
depthFailOp is a VkStencilOp value specifying the action performed on samples that pass the stencil test and fail the depth test.
compareOp is a VkCompareOp value specifying the comparison operator used in the stencil test.
compareMask selects the bits of the unsigned integer stencil values participating in the stencil test.
writeMask selects the bits of the unsigned integer stencil values updated by the stencil test in the stencil framebuffer attachment.
reference is an integer reference value that is used in the unsigned stencil comparison.

Valid Usage (Implicit)

VUID-VkStencilOpState-failOp-parameter
failOp must be a valid VkStencilOp value
VUID-VkStencilOpState-passOp-parameter
passOp must be a valid VkStencilOp value
VUID-VkStencilOpState-depthFailOp-parameter
depthFailOp must be a valid VkStencilOp value
VUID-VkStencilOpState-compareOp-parameter
compareOp must be a valid VkCompareOp value

There are two sets of stencil-related state, the front stencil state set and the back stencil state set. Stencil tests and writes use the front set of stencil state when processing front-facing fragments and use the back set of stencil state when processing back-facing fragments. Fragments rasterized from non-polygon primitives (points and lines) are always considered front-facing. Fragments rasterized from polygon primitives inherit their facingness from the polygon, even if the polygon is rasterized as points or lines due to the current VkPolygonMode. Whether a polygon is front- or back-facing is determined in the same manner used for face culling (see Basic Polygon Rasterization).

The operation of the stencil test is also affected by the compareMask, writeMask, and reference members of VkStencilOpState set in the pipeline state object if the pipeline state object is created without the VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK, VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, and VK_DYNAMIC_STATE_STENCIL_REFERENCE dynamic states enabled, respectively.

If the pipeline state object is created with the VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK dynamic state enabled, then to dynamically set the stencil compare mask call:

void vkCmdSetStencilCompareMask(
    VkCommandBuffer                             commandBuffer,
    VkStencilFaceFlags                          faceMask,
    uint32_t                                    compareMask);

commandBuffer is the command buffer into which the command will be recorded.
faceMask is a bitmask of VkStencilFaceFlagBits specifying the set of stencil state for which to update the compare mask.
compareMask is the new value to use as the stencil compare mask.

Valid Usage (Implicit)

VUID-vkCmdSetStencilCompareMask-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetStencilCompareMask-faceMask-parameter
faceMask must be a valid combination of VkStencilFaceFlagBits values
VUID-vkCmdSetStencilCompareMask-faceMask-requiredbitmask
faceMask must not be 0
VUID-vkCmdSetStencilCompareMask-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetStencilCompareMask-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

Bits which can be set in the vkCmdSetStencilCompareMask::faceMask parameter, and similar parameters of other commands specifying which stencil state to update stencil masks for, are:

typedef enum VkStencilFaceFlagBits {
    VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
    VK_STENCIL_FACE_BACK_BIT = 0x00000002,
    VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003,
    VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK,
    VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkStencilFaceFlagBits;

VK_STENCIL_FACE_FRONT_BIT specifies that only the front set of stencil state is updated.
VK_STENCIL_FACE_BACK_BIT specifies that only the back set of stencil state is updated.
VK_STENCIL_FACE_FRONT_AND_BACK is the combination of VK_STENCIL_FACE_FRONT_BIT and VK_STENCIL_FACE_BACK_BIT, and specifies that both sets of stencil state are updated.

typedef VkFlags VkStencilFaceFlags;

VkStencilFaceFlags is a bitmask type for setting a mask of zero or more VkStencilFaceFlagBits.

If the pipeline state object is created with the VK_DYNAMIC_STATE_STENCIL_WRITE_MASK dynamic state enabled, then to dynamically set the stencil write mask call:

void vkCmdSetStencilWriteMask(
    VkCommandBuffer                             commandBuffer,
    VkStencilFaceFlags                          faceMask,
    uint32_t                                    writeMask);

commandBuffer is the command buffer into which the command will be recorded.
faceMask is a bitmask of VkStencilFaceFlagBits specifying the set of stencil state for which to update the write mask, as described above for vkCmdSetStencilCompareMask.
writeMask is the new value to use as the stencil write mask.

Valid Usage (Implicit)

VUID-vkCmdSetStencilWriteMask-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetStencilWriteMask-faceMask-parameter
faceMask must be a valid combination of VkStencilFaceFlagBits values
VUID-vkCmdSetStencilWriteMask-faceMask-requiredbitmask
faceMask must not be 0
VUID-vkCmdSetStencilWriteMask-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetStencilWriteMask-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

If the pipeline state object is created with the VK_DYNAMIC_STATE_STENCIL_REFERENCE dynamic state enabled, then to dynamically set the stencil reference value call:

void vkCmdSetStencilReference(
    VkCommandBuffer                             commandBuffer,
    VkStencilFaceFlags                          faceMask,
    uint32_t                                    reference);

commandBuffer is the command buffer into which the command will be recorded.
faceMask is a bitmask of VkStencilFaceFlagBits specifying the set of stencil state for which to update the reference value, as described above for vkCmdSetStencilCompareMask.
reference is the new value to use as the stencil reference value.

Valid Usage (Implicit)

VUID-vkCmdSetStencilReference-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetStencilReference-faceMask-parameter
faceMask must be a valid combination of VkStencilFaceFlagBits values
VUID-vkCmdSetStencilReference-faceMask-requiredbitmask
faceMask must not be 0
VUID-vkCmdSetStencilReference-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetStencilReference-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

reference is an integer reference value that is used in the unsigned stencil comparison. The reference value used by stencil comparison must be within the range [0,2^s-1] , where s is the number of bits in the stencil framebuffer attachment, otherwise the reference value is considered undefined. The s least significant bits of compareMask are bitwise ANDed with both the reference and the stored stencil value, and the resulting masked values are those that participate in the comparison controlled by compareOp. Let R be the masked reference value and S be the masked stored stencil value.

Possible values of VkStencilOpState::compareOp, specifying the stencil comparison function, are:

typedef enum VkCompareOp {
    VK_COMPARE_OP_NEVER = 0,
    VK_COMPARE_OP_LESS = 1,
    VK_COMPARE_OP_EQUAL = 2,
    VK_COMPARE_OP_LESS_OR_EQUAL = 3,
    VK_COMPARE_OP_GREATER = 4,
    VK_COMPARE_OP_NOT_EQUAL = 5,
    VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
    VK_COMPARE_OP_ALWAYS = 7,
    VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
} VkCompareOp;

VK_COMPARE_OP_NEVER specifies that the test never passes.
VK_COMPARE_OP_LESS specifies that the test passes when R < S.
VK_COMPARE_OP_EQUAL specifies that the test passes when R = S.
VK_COMPARE_OP_LESS_OR_EQUAL specifies that the test passes when R ≤ S.
VK_COMPARE_OP_GREATER specifies that the test passes when R > S.
VK_COMPARE_OP_NOT_EQUAL specifies that the test passes when R ≠ S.
VK_COMPARE_OP_GREATER_OR_EQUAL specifies that the test passes when R ≥ S.
VK_COMPARE_OP_ALWAYS specifies that the test always passes.

Possible values of the failOp, passOp, and depthFailOp members of VkStencilOpState, specifying what happens to the stored stencil value if this or certain subsequent tests fail or pass, are:

typedef enum VkStencilOp {
    VK_STENCIL_OP_KEEP = 0,
    VK_STENCIL_OP_ZERO = 1,
    VK_STENCIL_OP_REPLACE = 2,
    VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
    VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
    VK_STENCIL_OP_INVERT = 5,
    VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
    VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
    VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
} VkStencilOp;

VK_STENCIL_OP_KEEP keeps the current value.
VK_STENCIL_OP_ZERO sets the value to 0.
VK_STENCIL_OP_REPLACE sets the value to reference.
VK_STENCIL_OP_INCREMENT_AND_CLAMP increments the current value and clamps to the maximum representable unsigned value.
VK_STENCIL_OP_DECREMENT_AND_CLAMP decrements the current value and clamps to 0.
VK_STENCIL_OP_INVERT bitwise-inverts the current value.
VK_STENCIL_OP_INCREMENT_AND_WRAP increments the current value and wraps to 0 when the maximum value would have been exceeded.
VK_STENCIL_OP_DECREMENT_AND_WRAP decrements the current value and wraps to the maximum possible value when the value would go below 0.

For purposes of increment and decrement, the stencil bits are considered as an unsigned integer.

If the stencil test fails, the sample’s coverage bit is cleared in the fragment. If there is no stencil framebuffer attachment, stencil modification cannot occur, and it is as if the stencil tests always pass.

If the stencil test passes, the writeMask member of the VkStencilOpState structures controls how the updated stencil value is written to the stencil framebuffer attachment.

The least significant s bits of writeMask, where s is the number of bits in the stencil framebuffer attachment, specify an integer mask. Where a 1 appears in this mask, the corresponding bit in the stencil value in the depth/stencil attachment is written; where a 0 appears, the bit is not written. The writeMask value uses either the front-facing or back-facing state based on the facingness of the fragment. Fragments generated by front-facing primitives use the front mask and fragments generated by back-facing primitives use the back mask.

27.13. Depth Test

The depth test conditionally disables coverage of a sample based on the outcome of a comparison between the fragment’s depth value at the sample location and the sample’s depth value in the depth/stencil attachment at location (x_f,y_f). The comparison is enabled or disabled with the depthTestEnable member of the VkPipelineDepthStencilStateCreateInfo structure. When disabled, the depth comparison and subsequent possible updates to the value of the depth component of the depth/stencil attachment are bypassed and the fragment is passed to the next operation. The stencil value, however, can be modified as indicated above as if the depth test passed. If enabled, the comparison takes place and the depth/stencil attachment value can subsequently be modified.

The comparison is specified with the depthCompareOp member of VkPipelineDepthStencilStateCreateInfo. Let z_f be the incoming fragment’s depth value for a sample, and let z_a be the depth/stencil attachment value in memory for that sample. The depth test passes under the following conditions:

VK_COMPARE_OP_NEVER: the test never passes.
VK_COMPARE_OP_LESS: the test passes when z_f < z_a.
VK_COMPARE_OP_EQUAL: the test passes when z_f = z_a.
VK_COMPARE_OP_LESS_OR_EQUAL: the test passes when z_f ≤ z_a.
VK_COMPARE_OP_GREATER: the test passes when z_f > z_a.
VK_COMPARE_OP_NOT_EQUAL: the test passes when z_f ≠ z_a.
VK_COMPARE_OP_GREATER_OR_EQUAL: the test passes when z_f ≥ z_a.
VK_COMPARE_OP_ALWAYS: the test always passes.

If VkPipelineRasterizationStateCreateInfo::depthClampEnable is enabled, before the incoming fragment’s z_f is compared to z_a, z_f is clamped to [min(n,f),max(n,f)], where n and f are the minDepth and maxDepth depth range values of the viewport used by this fragment, respectively.

If the depth test fails, the sample’s coverage bit is cleared in the fragment. The stencil value at the sample’s location is updated according to the function currently in effect for depth test failure.

If the depth test passes, the sample’s (possibly clamped) z_f value is conditionally written to the depth framebuffer attachment based on the depthWriteEnable member of VkPipelineDepthStencilStateCreateInfo. The value is written if depthWriteEnable is VK_TRUE and there is a depth framebuffer attachment. Otherwise, no value is written. If the depth framebuffer attachment is a fixed-point format and the depth value is outside of the 0.0 to 1.0 range the depth value is clamped between 0.0 and 1.0 inclusive before writing. The stencil value at the sample’s location is updated according to the function currently in effect for depth test success.

If there is no depth framebuffer attachment, it is as if the depth test always passes.

27.14. Representative Fragment Test

The representative fragment test allows implementations to reduce the amount of rasterization and fragment processing work performed for each point, line, or triangle primitive. For any primitive that produces one or more fragments that pass all prior early fragment tests, the implementation may choose one or more “representative” fragments for processing and discard all other fragments. For draw calls rendering multiple points, lines, or triangles arranged in lists, strips, or fans, the representative fragment test is performed independently for each of those primitives. The set of fragments discarded by the representative fragment test is implementation-dependent. In some cases, the representative fragment test may not discard any fragments for a given primitive.

If the pNext chain of VkGraphicsPipelineCreateInfo includes a VkPipelineRepresentativeFragmentTestStateCreateInfoNV structure, then that structure includes parameters that control the representative fragment test.

The VkPipelineRepresentativeFragmentTestStateCreateInfoNV structure is defined as:

typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV {
    VkStructureType    sType;
    const void*        pNext;
    VkBool32           representativeFragmentTestEnable;
} VkPipelineRepresentativeFragmentTestStateCreateInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
representativeFragmentTestEnable controls whether the representative fragment test is enabled.

If this structure is not present, representativeFragmentTestEnable is considered to be VK_FALSE, and the representative fragment test is disabled.

If early fragment tests are not enabled in the active fragment shader, the representative fragment shader test has no effect, even if enabled.

Valid Usage (Implicit)

VUID-VkPipelineRepresentativeFragmentTestStateCreateInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV

27.15. Sample Counting

Occlusion queries use query pool entries to track the number of samples that pass all the per-fragment tests. The mechanism of collecting an occlusion query value is described in Occlusion Queries.

The occlusion query sample counter increments by one for each sample with a coverage value of 1 in each fragment that survives all the per-fragment tests, including scissor, exclusive scissor, sample mask, alpha to coverage, stencil, and depth tests.

27.16. Fragment Coverage To Color

If the pNext chain of VkPipelineMultisampleStateCreateInfo includes a VkPipelineCoverageToColorStateCreateInfoNV structure, then that structure controls whether the fragment coverage is substituted for a fragment color output and, if so, which output is replaced.

The VkPipelineCoverageToColorStateCreateInfoNV structure is defined as:

typedef struct VkPipelineCoverageToColorStateCreateInfoNV {
    VkStructureType                                sType;
    const void*                                    pNext;
    VkPipelineCoverageToColorStateCreateFlagsNV    flags;
    VkBool32                                       coverageToColorEnable;
    uint32_t                                       coverageToColorLocation;
} VkPipelineCoverageToColorStateCreateInfoNV;

sType is the type of this structure
pNext is NULL or a pointer to an extension-specific structure
flags is reserved for future use.
coverageToColorEnable controls whether the fragment coverage value replaces a fragment color output.
coverageToColorLocation controls which fragment shader color output value is replaced.

If coverageToColorEnable is VK_TRUE, the fragment coverage information is treated as a bitmask with one bit for each sample (as in the Sample Mask section), and this bitmask replaces the first component of the color value corresponding to the fragment shader output location with Location equal to coverageToColorLocation and Index equal to zero. If the color attachment format has fewer bits than the sample coverage, the low bits of the sample coverage bitmask are taken without any clamping. If the color attachment format has more bits than the sample coverage, the high bits of the sample coverage bitmask are filled with zeros.

If Sample Shading is in use, the coverage bitmask only has bits set for samples that correspond to the fragment shader invocation that shades those samples.

This pipeline stage occurs after sample counting and before blending, and is always performed after fragment shading regardless of the setting of EarlyFragmentTests.

If coverageToColorEnable is VK_FALSE, these operations are skipped. If this structure is not present, it is as if coverageToColorEnable is VK_FALSE.

Valid Usage

VUID-VkPipelineCoverageToColorStateCreateInfoNV-coverageToColorEnable-01404
If coverageToColorEnable is VK_TRUE, then the render pass subpass indicated by VkGraphicsPipelineCreateInfo::renderPass and VkGraphicsPipelineCreateInfo::subpass must have a color attachment at the location selected by coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT

Valid Usage (Implicit)

VUID-VkPipelineCoverageToColorStateCreateInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV
VUID-VkPipelineCoverageToColorStateCreateInfoNV-flags-zerobitmask
flags must be 0

typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV;

VkPipelineCoverageToColorStateCreateFlagsNV is a bitmask type for setting a mask, but is currently reserved for future use.

27.17. Coverage Reduction

Coverage reduction generates a color sample mask from the coverage mask, with one bit for each sample in the color attachment(s) for the subpass. If a bit in the color sample mask is 0, then blending and writing to the framebuffer are not performed for that sample.

When the VK_NV_framebuffer_mixed_samples extension is not enabled, each color sample is associated with a unique rasterization sample, and the value of the coverage mask is assigned to the color sample mask.

If the render pass has a fragment density map attachment, rasterizationSamples is greater than 1, and the fragment area covers multiple pixels; there is an implementation-dependent association of rasterization samples to color attachment samples within the fragment. Each color sample’s mask bit is assigned the union of the coverage bits of its associated raster samples.

If the pipeline’s VkPipelineMultisampleStateCreateInfo::rasterizationSamples is greater than the VkAttachmentDescription::samples of the color attachments in the subpass, then the fragment’s coverage is reduced from rasterizationSamples bits to a color sample mask with VkAttachmentDescription::samples bits.

When the VK_NV_coverage_reduction_mode extension is enabled, the pipeline state controlling coverage reduction is specified through the members of the VkPipelineCoverageReductionStateCreateInfoNV structure.

The VkPipelineCoverageReductionStateCreateInfoNV structure is defined as:

typedef struct VkPipelineCoverageReductionStateCreateInfoNV {
    VkStructureType                                  sType;
    const void*                                      pNext;
    VkPipelineCoverageReductionStateCreateFlagsNV    flags;
    VkCoverageReductionModeNV                        coverageReductionMode;
} VkPipelineCoverageReductionStateCreateInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
coverageReductionMode is a VkCoverageReductionModeNV value controlling how the color sample mask is generated from the coverage mask.

If this structure is not present, the default coverage reduction mode is inferred as follows:

If the VK_NV_framebuffer_mixed_samples extension is enabled, then it is as if the coverageReductionMode is VK_COVERAGE_REDUCTION_MODE_MERGE_NV.
If the VK_AMD_mixed_attachment_samples extension is enabled, then it is as if the coverageReductionMode is VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV.
If both VK_NV_framebuffer_mixed_samples and VK_AMD_mixed_attachment_samples are enabled, then the default coverage reduction mode is implementation-dependent.

Valid Usage (Implicit)

VUID-VkPipelineCoverageReductionStateCreateInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV
VUID-VkPipelineCoverageReductionStateCreateInfoNV-flags-zerobitmask
flags must be 0
VUID-VkPipelineCoverageReductionStateCreateInfoNV-coverageReductionMode-parameter
coverageReductionMode must be a valid VkCoverageReductionModeNV value

typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV;

VkPipelineCoverageReductionStateCreateFlagsNV is a bitmask type for setting a mask, but is currently reserved for future use.

Possible values of VkPipelineCoverageReductionStateCreateInfoNV::coverageReductionMode, specifying how the coverage mask is reduced to color sample mask, are:

typedef enum VkCoverageReductionModeNV {
    VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0,
    VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1,
    VK_COVERAGE_REDUCTION_MODE_MAX_ENUM_NV = 0x7FFFFFFF
} VkCoverageReductionModeNV;

VK_COVERAGE_REDUCTION_MODE_MERGE_NV: In this mode, there is an implementation-dependent association of each raster sample to a color sample. The reduced color sample mask is computed such that the bit for each color sample is 1 if any of the associated bits in the fragment’s coverage is on, and 0 otherwise.
VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV: In this mode, only the first M raster samples are associated with the color samples such that raster sample i maps to color sample i, where M is the number of color samples.

If the VK_NV_coverage_reduction_mode extension is not enabled, there is an implementation-dependent association of raster samples to color samples. The reduced color sample mask is computed such that the bit for each color sample is 1 if any of the associated bits in the fragment’s coverage is on, and 0 otherwise.

To query the set of mixed sample combinations of coverage reduction mode, rasterization samples and color, depth, stencil attachment sample counts that are supported by a physical device, call:

VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pCombinationCount,
    VkFramebufferMixedSamplesCombinationNV*     pCombinations);

physicalDevice is the physical device from which to query the set of combinations.
pCombinationCount is a pointer to an integer related to the number of combinations available or queried, as described below.
pCombinations is either NULL or a pointer to an array of VkFramebufferMixedSamplesCombinationNV values, indicating the supported combinations of coverage reduction mode, rasterization samples, and color, depth, stencil attachment sample counts.

If pCombinations is NULL, then the number of supported combinations for the given physicalDevice is returned in pCombinationCount. Otherwise, pCombinationCount must point to a variable set by the user to the number of elements in the pCombinations array, and on return the variable is overwritten with the number of values actually written to pCombinations. If the value of pCombinationCount is less than the number of combinations supported for the given physicalDevice, at most pCombinationCount values will be written pCombinations and VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the supported values were returned.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV-pCombinationCount-parameter
pCombinationCount must be a valid pointer to a uint32_t value
VUID-vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV-pCombinations-parameter
If the value referenced by pCombinationCount is not 0, and pCombinations is not NULL, pCombinations must be a valid pointer to an array of pCombinationCount VkFramebufferMixedSamplesCombinationNV structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkFramebufferMixedSamplesCombinationNV structure is defined as:

typedef struct VkFramebufferMixedSamplesCombinationNV {
    VkStructureType              sType;
    void*                        pNext;
    VkCoverageReductionModeNV    coverageReductionMode;
    VkSampleCountFlagBits        rasterizationSamples;
    VkSampleCountFlags           depthStencilSamples;
    VkSampleCountFlags           colorSamples;
} VkFramebufferMixedSamplesCombinationNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
coverageReductionMode is a VkCoverageReductionModeNV value specifying the coverage reduction mode.
rasterizationSamples specifies the number of rasterization samples in the supported combination.
depthStencilSamples specifies the number of samples in the depth stencil attachment in the supported combination. A value of 0 indicates the combination does not have a depth stencil attachment.
colorSamples specifies the number of color samples in a color attachment in the supported combination. A value of 0 indicates the combination does not have a color attachment.

Valid Usage (Implicit)

VUID-VkFramebufferMixedSamplesCombinationNV-sType-sType
sType must be VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV
VUID-VkFramebufferMixedSamplesCombinationNV-pNext-pNext
pNext must be NULL

27.17.1. Coverage Modulation

As part of coverage reduction, fragment color values can also be modulated (multiplied) by a value that is a function of fraction of covered rasterization samples associated with that color sample.

Pipeline state controlling coverage modulation is specified through the members of the VkPipelineCoverageModulationStateCreateInfoNV structure.

The VkPipelineCoverageModulationStateCreateInfoNV structure is defined as:

typedef struct VkPipelineCoverageModulationStateCreateInfoNV {
    VkStructureType                                   sType;
    const void*                                       pNext;
    VkPipelineCoverageModulationStateCreateFlagsNV    flags;
    VkCoverageModulationModeNV                        coverageModulationMode;
    VkBool32                                          coverageModulationTableEnable;
    uint32_t                                          coverageModulationTableCount;
    const float*                                      pCoverageModulationTable;
} VkPipelineCoverageModulationStateCreateInfoNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
coverageModulationMode is a VkCoverageModulationModeNV value controlling which color components are modulated.
coverageModulationTableEnable controls whether the modulation factor is looked up from a table in pCoverageModulationTable.
coverageModulationTableCount is the number of elements in pCoverageModulationTable.
pCoverageModulationTable is a table of modulation factors containing a value for each number of covered samples.

If coverageModulationTableEnable is VK_FALSE, then for each color sample the associated bits of the fragment’s coverage are counted and divided by the number of associated bits to produce a modulation factor R in the range (0,1] (a value of zero would have been killed due to a color coverage of 0). Specifically:

N = value of rasterizationSamples
M = value of VkAttachmentDescription::samples for any color attachments
R = popcount(associated coverage bits) / (N / M)

If coverageModulationTableEnable is VK_TRUE, the value R is computed using a programmable lookup table. The lookup table has N / M elements, and the element of the table is selected by:

R = pCoverageModulationTable[popcount(associated coverage bits)-1]

Note that the table does not have an entry for popcount(associated coverage bits) = 0, because such samples would have been killed.

The values of pCoverageModulationTable may be rounded to an implementation-dependent precision, which is at least as fine as 1 / N, and clamped to [0,1].

For each color attachment with a floating point or normalized color format, each fragment output color value is replicated to M values which can each be modulated (multiplied) by that color sample’s associated value of R. Which components are modulated is controlled by coverageModulationMode.

If this structure is not present, it is as if coverageModulationMode is VK_COVERAGE_MODULATION_MODE_NONE_NV.

If the coverage reduction mode is VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV, each color sample is associated with only a single coverage sample. In this case, it is as if coverageModulationMode is VK_COVERAGE_MODULATION_MODE_NONE_NV.

Valid Usage

VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableEnable-01405
If coverageModulationTableEnable is VK_TRUE, coverageModulationTableCount must be equal to the number of rasterization samples divided by the number of color samples in the subpass

Valid Usage (Implicit)

VUID-VkPipelineCoverageModulationStateCreateInfoNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV
VUID-VkPipelineCoverageModulationStateCreateInfoNV-flags-zerobitmask
flags must be 0
VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationMode-parameter
coverageModulationMode must be a valid VkCoverageModulationModeNV value

typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV;

VkPipelineCoverageModulationStateCreateFlagsNV is a bitmask type for setting a mask, but is currently reserved for future use.

Possible values of VkPipelineCoverageModulationStateCreateInfoNV::coverageModulationMode, specifying which color components are modulated, are:

typedef enum VkCoverageModulationModeNV {
    VK_COVERAGE_MODULATION_MODE_NONE_NV = 0,
    VK_COVERAGE_MODULATION_MODE_RGB_NV = 1,
    VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2,
    VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3,
    VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF
} VkCoverageModulationModeNV;

VK_COVERAGE_MODULATION_MODE_NONE_NV specifies that no components are multiplied by the modulation factor.
VK_COVERAGE_MODULATION_MODE_RGB_NV specifies that the red, green, and blue components are multiplied by the modulation factor.
VK_COVERAGE_MODULATION_MODE_ALPHA_NV specifies that the alpha component is multiplied by the modulation factor.
VK_COVERAGE_MODULATION_MODE_RGBA_NV specifies that all components are multiplied by the modulation factor.

28. The Framebuffer

28.1. Blending

Blending combines the incoming source fragment’s R, G, B, and A values with the destination R, G, B, and A values of each sample stored in the framebuffer at the fragment’s (x_f,y_f) location. Blending is performed for each color sample covered by the fragment, rather than just once for each fragment.

Source and destination values are combined according to the blend operation, quadruplets of source and destination weighting factors determined by the blend factors, and a blend constant, to obtain a new set of R, G, B, and A values, as described below.

Blending is computed and applied separately to each color attachment used by the subpass, with separate controls for each attachment.

Prior to performing the blend operation, signed and unsigned normalized fixed-point color components undergo an implied conversion to floating-point as specified by Conversion from Normalized Fixed-Point to Floating-Point. Blending computations are treated as if carried out in floating-point, and basic blend operations are performed with a precision and dynamic range no lower than that used to represent destination components. Advanced blending operations are performed with a precision and dynamic range no lower than the smaller of that used to represent destination components or that used to represent 16-bit floating-point values.

Blending applies only to fixed-point and floating-point color attachments. If the color attachment has an integer format, blending is not applied.

The pipeline blend state is included in the VkPipelineColorBlendStateCreateInfo structure during graphics pipeline creation:

The VkPipelineColorBlendStateCreateInfo structure is defined as:

typedef struct VkPipelineColorBlendStateCreateInfo {
    VkStructureType                               sType;
    const void*                                   pNext;
    VkPipelineColorBlendStateCreateFlags          flags;
    VkBool32                                      logicOpEnable;
    VkLogicOp                                     logicOp;
    uint32_t                                      attachmentCount;
    const VkPipelineColorBlendAttachmentState*    pAttachments;
    float                                         blendConstants[4];
} VkPipelineColorBlendStateCreateInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
logicOpEnable controls whether to apply Logical Operations.
logicOp selects which logical operation to apply.
attachmentCount is the number of VkPipelineColorBlendAttachmentState elements in pAttachments. This value must equal the colorAttachmentCount for the subpass in which this pipeline is used.
pAttachments: is a pointer to an array of per target attachment states.
blendConstants is a pointer to an array of four values used as the R, G, B, and A components of the blend constant that are used in blending, depending on the blend factor.

Each element of the pAttachments array is a VkPipelineColorBlendAttachmentState structure specifying per-target blending state for each individual color attachment. If the independent blending feature is not enabled on the device, all VkPipelineColorBlendAttachmentState elements in the pAttachments array must be identical.

Valid Usage

VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-00605
If the independent blending feature is not enabled, all elements of pAttachments must be identical
VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00606
If the logic operations feature is not enabled, logicOpEnable must be VK_FALSE
VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00607
If logicOpEnable is VK_TRUE, logicOp must be a valid VkLogicOp value

Valid Usage (Implicit)

VUID-VkPipelineColorBlendStateCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO
VUID-VkPipelineColorBlendStateCreateInfo-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkPipelineColorBlendAdvancedStateCreateInfoEXT
VUID-VkPipelineColorBlendStateCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkPipelineColorBlendStateCreateInfo-flags-zerobitmask
flags must be 0
VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-parameter
If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkPipelineColorBlendAttachmentState structures

typedef VkFlags VkPipelineColorBlendStateCreateFlags;

VkPipelineColorBlendStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

The VkPipelineColorBlendAttachmentState structure is defined as:

typedef struct VkPipelineColorBlendAttachmentState {
    VkBool32                 blendEnable;
    VkBlendFactor            srcColorBlendFactor;
    VkBlendFactor            dstColorBlendFactor;
    VkBlendOp                colorBlendOp;
    VkBlendFactor            srcAlphaBlendFactor;
    VkBlendFactor            dstAlphaBlendFactor;
    VkBlendOp                alphaBlendOp;
    VkColorComponentFlags    colorWriteMask;
} VkPipelineColorBlendAttachmentState;

blendEnable controls whether blending is enabled for the corresponding color attachment. If blending is not enabled, the source fragment’s color for that attachment is passed through unmodified.
srcColorBlendFactor selects which blend factor is used to determine the source factors (S_r,S_g,S_b).
dstColorBlendFactor selects which blend factor is used to determine the destination factors (D_r,D_g,D_b).
colorBlendOp selects which blend operation is used to calculate the RGB values to write to the color attachment.
srcAlphaBlendFactor selects which blend factor is used to determine the source factor S_a.
dstAlphaBlendFactor selects which blend factor is used to determine the destination factor D_a.
alphaBlendOp selects which blend operation is use to calculate the alpha values to write to the color attachment.
colorWriteMask is a bitmask of VkColorComponentFlagBits specifying which of the R, G, B, and/or A components are enabled for writing, as described for the Color Write Mask.

Valid Usage

VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-00608
If the dual source blending feature is not enabled, srcColorBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-00609
If the dual source blending feature is not enabled, dstColorBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-00610
If the dual source blending feature is not enabled, srcAlphaBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-00611
If the dual source blending feature is not enabled, dstAlphaBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-01406
If either of colorBlendOp or alphaBlendOp is an advanced blend operation, then colorBlendOp must equal alphaBlendOp
VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01407
If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendIndependentBlend is VK_FALSE and colorBlendOp is an advanced blend operation, then colorBlendOp must be the same for all attachments.
VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01408
If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendIndependentBlend is VK_FALSE and alphaBlendOp is an advanced blend operation, then alphaBlendOp must be the same for all attachments.
VUID-VkPipelineColorBlendAttachmentState-advancedBlendAllOperations-01409
If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendAllOperations is VK_FALSE, then colorBlendOp must not be VK_BLEND_OP_ZERO_EXT, VK_BLEND_OP_SRC_EXT, VK_BLEND_OP_DST_EXT, VK_BLEND_OP_SRC_OVER_EXT, VK_BLEND_OP_DST_OVER_EXT, VK_BLEND_OP_SRC_IN_EXT, VK_BLEND_OP_DST_IN_EXT, VK_BLEND_OP_SRC_OUT_EXT, VK_BLEND_OP_DST_OUT_EXT, VK_BLEND_OP_SRC_ATOP_EXT, VK_BLEND_OP_DST_ATOP_EXT, VK_BLEND_OP_XOR_EXT, VK_BLEND_OP_INVERT_EXT, VK_BLEND_OP_INVERT_RGB_EXT, VK_BLEND_OP_LINEARDODGE_EXT, VK_BLEND_OP_LINEARBURN_EXT, VK_BLEND_OP_VIVIDLIGHT_EXT, VK_BLEND_OP_LINEARLIGHT_EXT, VK_BLEND_OP_PINLIGHT_EXT, VK_BLEND_OP_HARDMIX_EXT, VK_BLEND_OP_PLUS_EXT, VK_BLEND_OP_PLUS_CLAMPED_EXT, VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, VK_BLEND_OP_PLUS_DARKER_EXT, VK_BLEND_OP_MINUS_EXT, VK_BLEND_OP_MINUS_CLAMPED_EXT, VK_BLEND_OP_CONTRAST_EXT, VK_BLEND_OP_INVERT_OVG_EXT, VK_BLEND_OP_RED_EXT, VK_BLEND_OP_GREEN_EXT, or VK_BLEND_OP_BLUE_EXT
VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-01410
If colorBlendOp or alphaBlendOp is an advanced blend operation, then VkSubpassDescription::colorAttachmentCount of the subpass this pipeline is compiled against must be less than or equal to VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendMaxColorAttachments

Valid Usage (Implicit)

VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-parameter
srcColorBlendFactor must be a valid VkBlendFactor value
VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-parameter
dstColorBlendFactor must be a valid VkBlendFactor value
VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-parameter
colorBlendOp must be a valid VkBlendOp value
VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-parameter
srcAlphaBlendFactor must be a valid VkBlendFactor value
VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-parameter
dstAlphaBlendFactor must be a valid VkBlendFactor value
VUID-VkPipelineColorBlendAttachmentState-alphaBlendOp-parameter
alphaBlendOp must be a valid VkBlendOp value
VUID-VkPipelineColorBlendAttachmentState-colorWriteMask-parameter
colorWriteMask must be a valid combination of VkColorComponentFlagBits values

28.1.1. Blend Factors

The source and destination color and alpha blending factors are selected from the enum:

typedef enum VkBlendFactor {
    VK_BLEND_FACTOR_ZERO = 0,
    VK_BLEND_FACTOR_ONE = 1,
    VK_BLEND_FACTOR_SRC_COLOR = 2,
    VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
    VK_BLEND_FACTOR_DST_COLOR = 4,
    VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
    VK_BLEND_FACTOR_SRC_ALPHA = 6,
    VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
    VK_BLEND_FACTOR_DST_ALPHA = 8,
    VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
    VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
    VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
    VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
    VK_BLEND_FACTOR_SRC1_COLOR = 15,
    VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
    VK_BLEND_FACTOR_SRC1_ALPHA = 17,
    VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
    VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
} VkBlendFactor;

The semantics of each enum value is described in the table below:

Table 32. Blend Factors
VkBlendFactor	RGB Blend Factors (S_r,S_g,S_b) or (D_r,D_g,D_b)	Alpha Blend Factor (S_a or D_a)
`VK_BLEND_FACTOR_ZERO`	(0,0,0)	0
`VK_BLEND_FACTOR_ONE`	(1,1,1)	1
`VK_BLEND_FACTOR_SRC_COLOR`	(R_s0,G_s0,B_s0)	A_s0
`VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR`	(1-R_s0,1-G_s0,1-B_s0)	1-A_s0
`VK_BLEND_FACTOR_DST_COLOR`	(R_d,G_d,B_d)	A_d
`VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR`	(1-R_d,1-G_d,1-B_d)	1-A_d
`VK_BLEND_FACTOR_SRC_ALPHA`	(A_s0,A_s0,A_s0)	A_s0
`VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA`	(1-A_s0,1-A_s0,1-A_s0)	1-A_s0
`VK_BLEND_FACTOR_DST_ALPHA`	(A_d,A_d,A_d)	A_d
`VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA`	(1-A_d,1-A_d,1-A_d)	1-A_d
`VK_BLEND_FACTOR_CONSTANT_COLOR`	(R_c,G_c,B_c)	A_c
`VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR`	(1-R_c,1-G_c,1-B_c)	1-A_c
`VK_BLEND_FACTOR_CONSTANT_ALPHA`	(A_c,A_c,A_c)	A_c
`VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA`	(1-A_c,1-A_c,1-A_c)	1-A_c
`VK_BLEND_FACTOR_SRC_ALPHA_SATURATE`	(f,f,f); f = min(A_s0,1-A_d)	1
`VK_BLEND_FACTOR_SRC1_COLOR`	(R_s1,G_s1,B_s1)	A_s1
`VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR`	(1-R_s1,1-G_s1,1-B_s1)	1-A_s1
`VK_BLEND_FACTOR_SRC1_ALPHA`	(A_s1,A_s1,A_s1)	A_s1
`VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA`	(1-A_s1,1-A_s1,1-A_s1)	1-A_s1

In this table, the following conventions are used:

R_s0,G_s0,B_s0 and A_s0 represent the first source color R, G, B, and A components, respectively, for the fragment output location corresponding to the color attachment being blended.
R_s1,G_s1,B_s1 and A_s1 represent the second source color R, G, B, and A components, respectively, used in dual source blending modes, for the fragment output location corresponding to the color attachment being blended.
R_d,G_d,B_d and A_d represent the R, G, B, and A components of the destination color. That is, the color currently in the corresponding color attachment for this fragment/sample.
R_c,G_c,B_c and A_c represent the blend constant R, G, B, and A components, respectively.

If the pipeline state object is created without the VK_DYNAMIC_STATE_BLEND_CONSTANTS dynamic state enabled then the blend constant (R_c,G_c,B_c,A_c) is specified via the blendConstants member of VkPipelineColorBlendStateCreateInfo.

Otherwise, to dynamically set and change the blend constant, call:

void vkCmdSetBlendConstants(
    VkCommandBuffer                             commandBuffer,
    const float                                 blendConstants[4]);

commandBuffer is the command buffer into which the command will be recorded.
blendConstants is a pointer to 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.

Valid Usage (Implicit)

VUID-vkCmdSetBlendConstants-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetBlendConstants-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetBlendConstants-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics

28.1.2. Dual-Source Blending

Blend factors that use the secondary color input (R_s1,G_s1,B_s1,A_s1) (VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, and VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA) may consume implementation resources that could otherwise be used for rendering to multiple color attachments. Therefore, the number of color attachments that can be used in a framebuffer may be lower when using dual-source blending.

Dual-source blending is only supported if the dualSrcBlend feature is enabled.

The maximum number of color attachments that can be used in a subpass when using dual-source blending functions is implementation-dependent and is reported as the maxFragmentDualSrcAttachments member of VkPhysicalDeviceLimits.

When using a fragment shader with dual-source blending functions, the color outputs are bound to the first and second inputs of the blender using the Index decoration, as described in Fragment Output Interface. If the second color input to the blender is not written in the shader, or if no output is bound to the second input of a blender, the result of the blending operation is not defined.

28.1.3. Blend Operations

Once the source and destination blend factors have been selected, they along with the source and destination components are passed to the blending operations. RGB and alpha components can use different operations. Possible values of VkBlendOp, specifying the operations, are:

typedef enum VkBlendOp {
    VK_BLEND_OP_ADD = 0,
    VK_BLEND_OP_SUBTRACT = 1,
    VK_BLEND_OP_REVERSE_SUBTRACT = 2,
    VK_BLEND_OP_MIN = 3,
    VK_BLEND_OP_MAX = 4,
    VK_BLEND_OP_ZERO_EXT = 1000148000,
    VK_BLEND_OP_SRC_EXT = 1000148001,
    VK_BLEND_OP_DST_EXT = 1000148002,
    VK_BLEND_OP_SRC_OVER_EXT = 1000148003,
    VK_BLEND_OP_DST_OVER_EXT = 1000148004,
    VK_BLEND_OP_SRC_IN_EXT = 1000148005,
    VK_BLEND_OP_DST_IN_EXT = 1000148006,
    VK_BLEND_OP_SRC_OUT_EXT = 1000148007,
    VK_BLEND_OP_DST_OUT_EXT = 1000148008,
    VK_BLEND_OP_SRC_ATOP_EXT = 1000148009,
    VK_BLEND_OP_DST_ATOP_EXT = 1000148010,
    VK_BLEND_OP_XOR_EXT = 1000148011,
    VK_BLEND_OP_MULTIPLY_EXT = 1000148012,
    VK_BLEND_OP_SCREEN_EXT = 1000148013,
    VK_BLEND_OP_OVERLAY_EXT = 1000148014,
    VK_BLEND_OP_DARKEN_EXT = 1000148015,
    VK_BLEND_OP_LIGHTEN_EXT = 1000148016,
    VK_BLEND_OP_COLORDODGE_EXT = 1000148017,
    VK_BLEND_OP_COLORBURN_EXT = 1000148018,
    VK_BLEND_OP_HARDLIGHT_EXT = 1000148019,
    VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020,
    VK_BLEND_OP_DIFFERENCE_EXT = 1000148021,
    VK_BLEND_OP_EXCLUSION_EXT = 1000148022,
    VK_BLEND_OP_INVERT_EXT = 1000148023,
    VK_BLEND_OP_INVERT_RGB_EXT = 1000148024,
    VK_BLEND_OP_LINEARDODGE_EXT = 1000148025,
    VK_BLEND_OP_LINEARBURN_EXT = 1000148026,
    VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027,
    VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028,
    VK_BLEND_OP_PINLIGHT_EXT = 1000148029,
    VK_BLEND_OP_HARDMIX_EXT = 1000148030,
    VK_BLEND_OP_HSL_HUE_EXT = 1000148031,
    VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032,
    VK_BLEND_OP_HSL_COLOR_EXT = 1000148033,
    VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034,
    VK_BLEND_OP_PLUS_EXT = 1000148035,
    VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036,
    VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037,
    VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038,
    VK_BLEND_OP_MINUS_EXT = 1000148039,
    VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040,
    VK_BLEND_OP_CONTRAST_EXT = 1000148041,
    VK_BLEND_OP_INVERT_OVG_EXT = 1000148042,
    VK_BLEND_OP_RED_EXT = 1000148043,
    VK_BLEND_OP_GREEN_EXT = 1000148044,
    VK_BLEND_OP_BLUE_EXT = 1000148045,
    VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
} VkBlendOp;

The semantics of each basic blend operations is described in the table below:

Table 33. Basic Blend Operations
VkBlendOp	RGB Components	Alpha Component
`VK_BLEND_OP_ADD`	R = R_s0 × S_r + R_d × D_r G = G_s0 × S_g + G_d × D_g B = B_s0 × S_b + B_d × D_b	A = A_s0 × S_a + A_d × D_a
`VK_BLEND_OP_SUBTRACT`	R = R_s0 × S_r - R_d × D_r G = G_s0 × S_g - G_d × D_g B = B_s0 × S_b - B_d × D_b	A = A_s0 × S_a - A_d × D_a
`VK_BLEND_OP_REVERSE_SUBTRACT`	R = R_d × D_r - R_s0 × S_r G = G_d × D_g - G_s0 × S_g B = B_d × D_b - B_s0 × S_b	A = A_d × D_a - A_s0 × S_a
`VK_BLEND_OP_MIN`	R = min(R_s0,R_d) G = min(G_s0,G_d) B = min(B_s0,B_d)	A = min(A_s0,A_d)
`VK_BLEND_OP_MAX`	R = max(R_s0,R_d) G = max(G_s0,G_d) B = max(B_s0,B_d)	A = max(A_s0,A_d)

In this table, the following conventions are used:

R_s0, G_s0, B_s0 and A_s0 represent the first source color R, G, B, and A components, respectively.
R_d, G_d, B_d and A_d represent the R, G, B, and A components of the destination color. That is, the color currently in the corresponding color attachment for this fragment/sample.
S_r, S_g, S_b and S_a represent the source blend factor R, G, B, and A components, respectively.
D_r, D_g, D_b and D_a represent the destination blend factor R, G, B, and A components, respectively.

The blending operation produces a new set of values R, G, B and A, which are written to the framebuffer attachment. If blending is not enabled for this attachment, then R, G, B and A are assigned R_s0, G_s0, B_s0 and A_s0, respectively.

If the color attachment is fixed-point, the components of the source and destination values and blend factors are each clamped to [0,1] or [-1,1] respectively for an unsigned normalized or signed normalized color attachment prior to evaluating the blend operations. If the color attachment is floating-point, no clamping occurs.

If the numeric format of a framebuffer attachment uses sRGB encoding, the R, G, and B destination color values (after conversion from fixed-point to floating-point) are considered to be encoded for the sRGB color space and hence are linearized prior to their use in blending. Each R, G, and B component is converted from nonlinear to linear as described in the “sRGB EOTF” section of the Khronos Data Format Specification. If the format is not sRGB, no linearization is performed.

If the numeric format of a framebuffer attachment uses sRGB encoding, then the final R, G and B values are converted into the nonlinear sRGB representation before being written to the framebuffer attachment as described in the “sRGB EOTF^-1” section of the Khronos Data Format Specification.

If the framebuffer color attachment numeric format is not sRGB encoded then the resulting c_s values for R, G and B are unmodified. The value of A is never sRGB encoded. That is, the alpha component is always stored in memory as linear.

If the framebuffer color attachment is VK_ATTACHMENT_UNUSED, no writes are performed through that attachment. Framebuffer color attachments greater than or equal to VkSubpassDescription::colorAttachmentCount perform no writes.

28.1.4. Advanced Blend Operations

The advanced blend operations are those listed in tables f/X/Y/Z Advanced Blend Operations, Hue-Saturation-Luminosity Advanced Blend Operations, and Additional RGB Blend Operations.

If the pNext chain of VkPipelineColorBlendStateCreateInfo includes a VkPipelineColorBlendAdvancedStateCreateInfoEXT structure, then that structure includes parameters that affect advanced blend operations.

The VkPipelineColorBlendAdvancedStateCreateInfoEXT structure is defined as:

typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {
    VkStructureType      sType;
    const void*          pNext;
    VkBool32             srcPremultiplied;
    VkBool32             dstPremultiplied;
    VkBlendOverlapEXT    blendOverlap;
} VkPipelineColorBlendAdvancedStateCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
srcPremultiplied specifies whether the source color of the blend operation is treated as premultiplied.
dstPremultiplied specifies whether the destination color of the blend operation is treated as premultiplied.
blendOverlap is a VkBlendOverlapEXT value specifying how the source and destination sample’s coverage is correlated.

If this structure is not present, srcPremultiplied and dstPremultiplied are both considered to be VK_TRUE, and blendOverlap is considered to be VK_BLEND_OVERLAP_UNCORRELATED_EXT.

Valid Usage

VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-srcPremultiplied-01424
If the non-premultiplied source color property is not supported, srcPremultiplied must be VK_TRUE
VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-dstPremultiplied-01425
If the non-premultiplied destination color property is not supported, dstPremultiplied must be VK_TRUE
VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-blendOverlap-01426
If the correlated overlap property is not supported, blendOverlap must be VK_BLEND_OVERLAP_UNCORRELATED_EXT

Valid Usage (Implicit)

VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT
VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-blendOverlap-parameter
blendOverlap must be a valid VkBlendOverlapEXT value

When using one of the operations in table f/X/Y/Z Advanced Blend Operations or Hue-Saturation-Luminosity Advanced Blend Operations, blending is performed according to the following equations:

\[\begin{aligned} R & = & f(R_s',R_d')*p_0(A_s,A_d) & + & Y*R_s'*p_1(A_s,A_d) & + & Z*R_d'*p_2(A_s,A_d) \\ G & = & f(G_s',G_d')*p_0(A_s,A_d) & + & Y*G_s'*p_1(A_s,A_d) & + & Z*G_d'*p_2(A_s,A_d) \\ B & = & f(B_s',B_d')*p_0(A_s,A_d) & + & Y*B_s'*p_1(A_s,A_d) & + & Z*B_d'*p_2(A_s,A_d) \\ A & = & X*p_0(A_s,A_d) & + & Y*p_1(A_s,A_d) & + & Z*p_2(A_s,A_d) \end{aligned}\]

where the function f and terms X, Y, and Z are specified in the table. The R, G, and B components of the source color used for blending are derived according to srcPremultiplied. If srcPremultiplied is set to VK_TRUE, the fragment color components are considered to have been premultiplied by the A component prior to blending. The base source color (R_s',G_s',B_s') is obtained by dividing through by the A component:

\[\begin{aligned} (R_s', G_s', B_s') & = \begin{cases} (0, 0, 0) & A_s = 0 \\ (\frac{R_s}{A_s}, \frac{G_s}{A_s}, \frac{B_s}{A_s}) & \text{otherwise} \end{cases} \end{aligned}\]

If srcPremultiplied is VK_FALSE, the fragment color components are used as the base color:

\[\begin{aligned} (R_s', G_s', B_s') & = (R_s, G_s, B_s) \end{aligned}\]

The R, G, and B components of the destination color used for blending are derived according to dstPremultiplied. If dstPremultiplied is set to VK_TRUE, the destination components are considered to have been premultiplied by the A component prior to blending. The base destination color (R_d',G_d',B_d') is obtained by dividing through by the A component:

\[\begin{aligned} (R_d', G_d', B_d') & = \begin{cases} (0, 0, 0) & A_d = 0 \\ (\frac{R_d}{A_d}, \frac{G_d}{A_d}, \frac{B_d}{A_d}) & \text{otherwise} \end{cases} \end{aligned}\]

If dstPremultiplied is VK_FALSE, the destination color components are used as the base color:

\[\begin{aligned} (R_d', G_d', B_d') & = (R_d, G_d, B_d) \end{aligned}\]

When blending using advanced blend operations, we expect that the R, G, and B components of premultiplied source and destination color inputs be stored as the product of non-premultiplied R, G, and B component values and the A component of the color. If any R, G, or B component of a premultiplied input color is non-zero and the A component is zero, the color is considered ill-formed, and the corresponding component of the blend result is undefined.

All of the advanced blend operation formulas in this chapter compute the result as a premultiplied color. If dstPremultiplied is VK_FALSE, that result color’s R, G, and B components are divided by the A component before being written to the framebuffer. If any R, G, or B component of the color is non-zero and the A component is zero, the result is considered ill-formed, and the corresponding component of the blend result is undefined. If all components are zero, that value is unchanged.

If the A component of any input or result color is less than zero, the color is considered ill-formed, and all components of the blend result are undefined.

The weighting functions p₀, p₁, and p₂ are defined in table Advanced Blend Overlap Modes. In these functions, the A components of the source and destination colors are taken to indicate the portion of the pixel covered by the fragment (source) and the fragments previously accumulated in the pixel (destination). The functions p₀, p₁, and p₂ approximate the relative portion of the pixel covered by the intersection of the source and destination, covered only by the source, and covered only by the destination, respectively.

Possible values of VkPipelineColorBlendAdvancedStateCreateInfoEXT::blendOverlap, specifying the blend overlap functions, are:

typedef enum VkBlendOverlapEXT {
    VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0,
    VK_BLEND_OVERLAP_DISJOINT_EXT = 1,
    VK_BLEND_OVERLAP_CONJOINT_EXT = 2,
    VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF
} VkBlendOverlapEXT;

VK_BLEND_OVERLAP_UNCORRELATED_EXT specifies that there is no correlation between the source and destination coverage.
VK_BLEND_OVERLAP_CONJOINT_EXT specifies that the source and destination coverage are considered to have maximal overlap.
VK_BLEND_OVERLAP_DISJOINT_EXT specifies that the source and destination coverage are considered to have minimal overlap.

Table 34. Advanced Blend Overlap Modes
Overlap Mode	Weighting Equations
`VK_BLEND_OVERLAP_UNCORRELATED_EXT`	\[ \begin{aligned} p_0(A_s,A_d) & = A_sA_d \\ p_1(A_s,A_d) & = A_s(1-A_d) \\ p_2(A_s,A_d) & = A_d(1-A_s) \\ \end{aligned}\]
`VK_BLEND_OVERLAP_CONJOINT_EXT`	\[ \begin{aligned} p_0(A_s,A_d) & = min(A_s,A_d) \\ p_1(A_s,A_d) & = max(A_s-A_d,0) \\ p_2(A_s,A_d) & = max(A_d-A_s,0) \\ \end{aligned}\]
`VK_BLEND_OVERLAP_DISJOINT_EXT`	\[ \begin{aligned} p_0(A_s,A_d) & = max(A_s+A_d-1,0) \\ p_1(A_s,A_d) & = min(A_s,1-A_d) \\ p_2(A_s,A_d) & = min(A_d,1-A_s) \\ \end{aligned}\]

Table 35. f/X/Y/Z Advanced Blend Operations
Mode	Blend Coefficients
`VK_BLEND_OP_ZERO_EXT`	\[ \begin{aligned} (X,Y,Z) & = (0,0,0) \\ f(C_s,C_d) & = 0 \end{aligned}\]
`VK_BLEND_OP_SRC_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,0) \\ f(C_s,C_d) & = C_s \end{aligned}\]
`VK_BLEND_OP_DST_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,0,1) \\ f(C_s,C_d) & = C_d \end{aligned}\]
`VK_BLEND_OP_SRC_OVER_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = C_s \end{aligned}\]
`VK_BLEND_OP_DST_OVER_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = C_d \end{aligned}\]
`VK_BLEND_OP_SRC_IN_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,0,0) \\ f(C_s,C_d) & = C_s \end{aligned}\]
`VK_BLEND_OP_DST_IN_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,0,0) \\ f(C_s,C_d) & = C_d \end{aligned}\]
`VK_BLEND_OP_SRC_OUT_EXT`	\[ \begin{aligned} (X,Y,Z) & = (0,1,0) \\ f(C_s,C_d) & = 0 \end{aligned}\]
`VK_BLEND_OP_DST_OUT_EXT`	\[ \begin{aligned} (X,Y,Z) & = (0,0,1) \\ f(C_s,C_d) & = 0 \end{aligned}\]
`VK_BLEND_OP_SRC_ATOP_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,0,1) \\ f(C_s,C_d) & = C_s \end{aligned}\]
`VK_BLEND_OP_DST_ATOP_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,0) \\ f(C_s,C_d) & = C_d \end{aligned}\]
`VK_BLEND_OP_XOR_EXT`	\[ \begin{aligned} (X,Y,Z) & = (0,1,1) \\ f(C_s,C_d) & = 0 \end{aligned}\]
`VK_BLEND_OP_MULTIPLY_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = C_sC_d \end{aligned}\]
`VK_BLEND_OP_SCREEN_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = C_s+C_d-C_sC_d \end{aligned}\]
`VK_BLEND_OP_OVERLAY_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = \begin{cases} 2 C_sC_d & C_d \leq 0.5 \\ 1-2 (1-C_s)(1-C_d) & \text{otherwise} \end{cases} \end{aligned}\]
`VK_BLEND_OP_DARKEN_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = min(C_s,C_d) \end{aligned}\]
`VK_BLEND_OP_LIGHTEN_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = max(C_s,C_d) \end{aligned}\]
`VK_BLEND_OP_COLORDODGE_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = \begin{cases} 0 & C_d \leq 0 \\ min(1,\frac{C_d}{1-C_s}) & C_d \gt 0 \text{ and } C_s \lt 1 \\ 1 & C_d \gt 0 \text{ and } C_s \geq 1 \end{cases} \end{aligned}\]
`VK_BLEND_OP_COLORBURN_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = \begin{cases} 1 & C_d \geq 1 \\ 1 - min(1,\frac{1-C_d}{C_s}) & C_d \lt 1 \text{ and } C_s \gt 0 \\ 0 & C_d \lt 1 \text{ and } C_s \leq 0 \end{cases} \end{aligned}\]
`VK_BLEND_OP_HARDLIGHT_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = \begin{cases} 2 C_sC_d & C_s \leq 0.5 \\ 1-2 (1-C_s)(1-C_d) & \text{otherwise} \end{cases} \end{aligned}\]
`VK_BLEND_OP_SOFTLIGHT_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = \begin{cases} C_d-(1-2 C_s)C_d(1-C_d) & C_s \leq 0.5 \\ C_d+(2 C_s-1)C_d((16 C_d-12)C_d+3) & C_s \gt 0.5 \text{ and } C_d \leq 0.25 \\ C_d+(2 C_s-1)(\sqrt{C_d}-C_d) & C_s \gt 0.5 \text{ and } C_d \gt 0.25 \end{cases} \end{aligned}\]
`VK_BLEND_OP_DIFFERENCE_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = \lvert C_d-C_s \rvert \end{aligned}\]
`VK_BLEND_OP_EXCLUSION_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = C_s+C_d-2C_sC_d \end{aligned}\]
`VK_BLEND_OP_INVERT_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,0,1) \\ f(C_s,C_d) & = 1-C_d \end{aligned}\]
`VK_BLEND_OP_INVERT_RGB_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,0,1) \\ f(C_s,C_d) & = C_s(1-C_d) \end{aligned}\]
`VK_BLEND_OP_LINEARDODGE_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = \begin{cases} C_s+C_d & C_s+C_d \leq 1 \\ 1 & \text{otherwise} \end{cases} \end{aligned}\]
`VK_BLEND_OP_LINEARBURN_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = \begin{cases} C_s+C_d-1 & C_s+C_d \gt 1 \\ 0 & \text{otherwise} \end{cases} \end{aligned}\]
`VK_BLEND_OP_VIVIDLIGHT_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = \begin{cases} 1-min(1,\frac{1-C_d}{2C_s}) & 0 \lt C_s \lt 0.5 \\ 0 & C_s \leq 0 \\ min(1,\frac{C_d}{2(1-C_s)}) & 0.5 \leq C_s \lt 1 \\ 1 & C_s \geq 1 \end{cases} \end{aligned}\]
`VK_BLEND_OP_LINEARLIGHT_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = \begin{cases} 1 & 2C_s+C_d \gt 2 \\ 2C_s+C_d-1 & 1 \lt 2C_s+C_d \leq 2 \\ 0 & 2C_s+C_d \leq 1 \end{cases} \end{aligned}\]
`VK_BLEND_OP_PINLIGHT_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = \begin{cases} 0 & 2C_s-1 \gt C_d \text{ and } C_s \lt 0.5 \\ 2C_s-1 & 2C_s-1 \gt C_d \text{ and } C_s \geq 0.5 \\ 2C_s & 2C_s-1 \leq C_d \text{ and } C_s \lt 0.5C_d \\ C_d & 2C_s-1 \leq C_d \text{ and } C_s \geq 0.5C_d \end{cases} \end{aligned}\]
`VK_BLEND_OP_HARDMIX_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = \begin{cases} 0 & C_s+C_d \lt 1 \\ 1 & \text{otherwise} \end{cases} \end{aligned}\]

When using one of the HSL blend operations in table Hue-Saturation-Luminosity Advanced Blend Operations as the blend operation, the RGB color components produced by the function f are effectively obtained by converting both the non-premultiplied source and destination colors to the HSL (hue, saturation, luminosity) color space, generating a new HSL color by selecting H, S, and L components from the source or destination according to the blend operation, and then converting the result back to RGB. In the equations below, a blended RGB color is produced according to the following pseudocode:

  float minv3(vec3 c) {
    return min(min(c.r, c.g), c.b);
  }
  float maxv3(vec3 c) {
    return max(max(c.r, c.g), c.b);
  }
  float lumv3(vec3 c) {
    return dot(c, vec3(0.30, 0.59, 0.11));
  }
  float satv3(vec3 c) {
    return maxv3(c) - minv3(c);
  }

  // If any color components are outside [0,1], adjust the color to
  // get the components in range.
  vec3 ClipColor(vec3 color) {
    float lum = lumv3(color);
    float mincol = minv3(color);
    float maxcol = maxv3(color);
    if (mincol < 0.0) {
      color = lum + ((color-lum)*lum) / (lum-mincol);
    }
    if (maxcol > 1.0) {
      color = lum + ((color-lum)*(1-lum)) / (maxcol-lum);
    }
    return color;
  }

  // Take the base RGB color <cbase> and override its luminosity
  // with that of the RGB color <clum>.
  vec3 SetLum(vec3 cbase, vec3 clum) {
    float lbase = lumv3(cbase);
    float llum = lumv3(clum);
    float ldiff = llum - lbase;
    vec3 color = cbase + vec3(ldiff);
    return ClipColor(color);
  }

  // Take the base RGB color <cbase> and override its saturation with
  // that of the RGB color <csat>.  The override the luminosity of the
  // result with that of the RGB color <clum>.
  vec3 SetLumSat(vec3 cbase, vec3 csat, vec3 clum)
  {
    float minbase = minv3(cbase);
    float sbase = satv3(cbase);
    float ssat = satv3(csat);
    vec3 color;
    if (sbase > 0) {
      // Equivalent (modulo rounding errors) to setting the
      // smallest (R,G,B) component to 0, the largest to <ssat>,
      // and interpolating the "middle" component based on its
      // original value relative to the smallest/largest.
      color = (cbase - minbase) * ssat / sbase;
    } else {
      color = vec3(0.0);
    }
    return SetLum(color, clum);
  }

Table 36. Hue-Saturation-Luminosity Advanced Blend Operations
Mode	Result
`VK_BLEND_OP_HSL_HUE_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = SetLumSat(C_s,C_d,C_d) \end{aligned}\]
`VK_BLEND_OP_HSL_SATURATION_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = SetLumSat(C_d,C_s,C_d) \end{aligned}\]
`VK_BLEND_OP_HSL_COLOR_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = SetLum(C_s,C_d) \end{aligned}\]
`VK_BLEND_OP_HSL_LUMINOSITY_EXT`	\[ \begin{aligned} (X,Y,Z) & = (1,1,1) \\ f(C_s,C_d) & = SetLum(C_d,C_s) \end{aligned}\]

When using one of the operations in table Additional RGB Blend Operations as the blend operation, the source and destination colors used by these blending operations are interpreted according to srcPremultiplied and dstPremultiplied. The blending operations below are evaluated where the RGB source and destination color components are both considered to have been premultiplied by the corresponding A component.

\[\begin{aligned} (R_s', G_s', B_s') & = \begin{cases} (R_s, G_s, B_s) & \text{if srcPremultiplied is VK\_TRUE} \\ (R_sA_s, G_sA_s, B_sA_s) & \text{if srcPremultiplied is VK\_FALSE} \end{cases} \\ (R_d', G_d', B_d') & = \begin{cases} (R_d, G_d, B_d) & \text{if dstPremultiplied is VK\_TRUE} \\ (R_dA_d, G_dA_d, B_dA_d) & \text{if dstPremultiplied is VK\_FALSE} \end{cases} \end{aligned}\]

Table 37. Additional RGB Blend Operations
Mode	Result
`VK_BLEND_OP_PLUS_EXT`	\[ \begin{aligned} (R,G,B,A) = ( & R_s'+R_d', \\ & G_s'+G_d', \\ & B_s'+B_d', \\ & A_s+A_d) \end{aligned}\]
`VK_BLEND_OP_PLUS_CLAMPED_EXT`	\[ \begin{aligned} (R,G,B,A) = ( & min(1,R_s'+R_d'), \\ & min(1,G_s'+G_d'), \\ & min(1,B_s'+B_d'), \\ & min(1,A_s+A_d)) \end{aligned}\]
`VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT`	\[ \begin{aligned} (R,G,B,A) = ( & min(min(1,A_s+A_d),R_s'+R_d'), \\ & min(min(1,A_s+A_d),G_s'+G_d'), \\ & min(min(1,A_s+A_d),B_s'+B_d'), \\ & min(1,A_s+A_d)) \end{aligned}\]
`VK_BLEND_OP_PLUS_DARKER_EXT`	\[ \begin{aligned} (R,G,B,A) = ( & max(0,min(1,A_s+A_d)-((A_s-R_s')+(A_d-R_d'))), \\ & max(0,min(1,A_s+A_d)-((A_s-G_s')+(A_d-G_d'))), \\ & max(0,min(1,A_s+A_d)-((A_s-B_s')+(A_d-B_d'))), \\ & min(1,A_s+A_d)) \end{aligned}\]
`VK_BLEND_OP_MINUS_EXT`	\[ \begin{aligned} (R,G,B,A) = ( & R_d'-R_s', \\ & G_d'-G_s', \\ & B_d'-B_s', \\ & A_d-A_s) \end{aligned}\]
`VK_BLEND_OP_MINUS_CLAMPED_EXT`	\[ \begin{aligned} (R,G,B,A) = ( & max(0,R_d'-R_s'), \\ & max(0,G_d'-G_s'), \\ & max(0,B_d'-B_s'), \\ & max(0,A_d-A_s)) \end{aligned}\]
`VK_BLEND_OP_CONTRAST_EXT`	\[ \begin{aligned} (R,G,B,A) = ( & \frac{A_d}{2} + 2(R_d'-\frac{A_d}{2})(R_s'-\frac{A_s}{2}), \\ & \frac{A_d}{2} + 2(G_d'-\frac{A_d}{2})(G_s'-\frac{A_s}{2}), \\ & \frac{A_d}{2} + 2(B_d'-\frac{A_d}{2})(B_s'-\frac{A_s}{2}), \\ & A_d) \end{aligned}\]
`VK_BLEND_OP_INVERT_OVG_EXT`	\[ \begin{aligned} (R,G,B,A) = ( & A_s(1-R_d') + (1-A_s)R_d', \\ & A_s(1-G_d') + (1-A_s)G_d', \\ & A_s(1-B_d') + (1-A_s)B_d', \\ & A_s+A_d-A_sA_d) \end{aligned}\]
`VK_BLEND_OP_RED_EXT`	\[ \begin{aligned} (R,G,B,A) & = (R_s', G_d', B_d', A_d) \end{aligned}\]
`VK_BLEND_OP_GREEN_EXT`	\[ \begin{aligned} (R,G,B,A) & = (R_d', G_s', B_d', A_d) \end{aligned}\]
`VK_BLEND_OP_BLUE_EXT`	\[ \begin{aligned} (R,G,B,A) & = (R_d', G_d', B_s', A_d) \end{aligned}\]

28.2. Logical Operations

The application can enable a logical operation between the fragment’s color values and the existing value in the framebuffer attachment. This logical operation is applied prior to updating the framebuffer attachment. Logical operations are applied only for signed and unsigned integer and normalized integer framebuffers. Logical operations are not applied to floating-point or sRGB format color attachments.

Logical operations are controlled by the logicOpEnable and logicOp members of VkPipelineColorBlendStateCreateInfo. If logicOpEnable is VK_TRUE, then a logical operation selected by logicOp is applied between each color attachment and the fragment’s corresponding output value, and blending of all attachments is treated as if it were disabled. Any attachments using color formats for which logical operations are not supported simply pass through the color values unmodified. The logical operation is applied independently for each of the red, green, blue, and alpha components. The logicOp is selected from the following operations:

typedef enum VkLogicOp {
    VK_LOGIC_OP_CLEAR = 0,
    VK_LOGIC_OP_AND = 1,
    VK_LOGIC_OP_AND_REVERSE = 2,
    VK_LOGIC_OP_COPY = 3,
    VK_LOGIC_OP_AND_INVERTED = 4,
    VK_LOGIC_OP_NO_OP = 5,
    VK_LOGIC_OP_XOR = 6,
    VK_LOGIC_OP_OR = 7,
    VK_LOGIC_OP_NOR = 8,
    VK_LOGIC_OP_EQUIVALENT = 9,
    VK_LOGIC_OP_INVERT = 10,
    VK_LOGIC_OP_OR_REVERSE = 11,
    VK_LOGIC_OP_COPY_INVERTED = 12,
    VK_LOGIC_OP_OR_INVERTED = 13,
    VK_LOGIC_OP_NAND = 14,
    VK_LOGIC_OP_SET = 15,
    VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
} VkLogicOp;

The logical operations supported by Vulkan are summarized in the following table in which

¬ is bitwise invert,
∧ is bitwise and,
∨ is bitwise or,
⊕ is bitwise exclusive or,
s is the fragment’s R_s0, G_s0, B_s0 or A_s0 component value for the fragment output corresponding to the color attachment being updated, and
d is the color attachment’s R, G, B or A component value:

Table 38. Logical Operations
Mode	Operation
`VK_LOGIC_OP_CLEAR`	0
`VK_LOGIC_OP_AND`	s ∧ d
`VK_LOGIC_OP_AND_REVERSE`	s ∧ ¬ d
`VK_LOGIC_OP_COPY`	s
`VK_LOGIC_OP_AND_INVERTED`	¬ s ∧ d
`VK_LOGIC_OP_NO_OP`	d
`VK_LOGIC_OP_XOR`	s ⊕ d
`VK_LOGIC_OP_OR`	s ∨ d
`VK_LOGIC_OP_NOR`	¬ (s ∨ d)
`VK_LOGIC_OP_EQUIVALENT`	¬ (s ⊕ d)
`VK_LOGIC_OP_INVERT`	¬ d
`VK_LOGIC_OP_OR_REVERSE`	s ∨ ¬ d
`VK_LOGIC_OP_COPY_INVERTED`	¬ s
`VK_LOGIC_OP_OR_INVERTED`	¬ s ∨ d
`VK_LOGIC_OP_NAND`	¬ (s ∧ d)
`VK_LOGIC_OP_SET`	all 1s

The result of the logical operation is then written to the color attachment as controlled by the component write mask, described in Blend Operations.

28.3. Color Write Mask

Bits which can be set in VkPipelineColorBlendAttachmentState::colorWriteMask to determine whether the final color values R, G, B and A are written to the framebuffer attachment are:

typedef enum VkColorComponentFlagBits {
    VK_COLOR_COMPONENT_R_BIT = 0x00000001,
    VK_COLOR_COMPONENT_G_BIT = 0x00000002,
    VK_COLOR_COMPONENT_B_BIT = 0x00000004,
    VK_COLOR_COMPONENT_A_BIT = 0x00000008,
    VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkColorComponentFlagBits;

VK_COLOR_COMPONENT_R_BIT specifies that the R value is written to the color attachment for the appropriate sample. Otherwise, the value in memory is unmodified.
VK_COLOR_COMPONENT_G_BIT specifies that the G value is written to the color attachment for the appropriate sample. Otherwise, the value in memory is unmodified.
VK_COLOR_COMPONENT_B_BIT specifies that the B value is written to the color attachment for the appropriate sample. Otherwise, the value in memory is unmodified.
VK_COLOR_COMPONENT_A_BIT specifies that the A value is written to the color attachment for the appropriate sample. Otherwise, the value in memory is unmodified.

The color write mask operation is applied regardless of whether blending is enabled.

typedef VkFlags VkColorComponentFlags;

VkColorComponentFlags is a bitmask type for setting a mask of zero or more VkColorComponentFlagBits.

29. Dispatching Commands

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 bound compute pipeline. A compute pipeline must be bound to a command buffer before any dispatch commands are recorded in that command buffer.

To record a dispatch, call:

void vkCmdDispatch(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    groupCountX,
    uint32_t                                    groupCountY,
    uint32_t                                    groupCountZ);

commandBuffer is the command buffer into which the command will be recorded.
groupCountX is the number of local workgroups to dispatch in the X dimension.
groupCountY is the number of local workgroups to dispatch in the Y dimension.
groupCountZ is the number of local workgroups to dispatch in the Z dimension.

When the command is executed, a global workgroup consisting of groupCountX × groupCountY × groupCountZ local workgroups is assembled.

Valid Usage

VUID-vkCmdDispatch-None-02690
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
VUID-vkCmdDispatch-None-02691
If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
VUID-vkCmdDispatch-None-02692
If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT
VUID-vkCmdDispatch-filterCubic-02694
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDispatch-filterCubicMinmax-02695
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDispatch-flags-02696
Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.
VUID-vkCmdDispatch-None-02697
For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDispatch-None-02698
For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDispatch-None-02699
Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command
VUID-vkCmdDispatch-None-02700
A valid pipeline must be bound to the pipeline bind point used by this command
VUID-vkCmdDispatch-commandBuffer-02701
If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic
VUID-vkCmdDispatch-None-02859
There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound
VUID-vkCmdDispatch-None-02702
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
VUID-vkCmdDispatch-None-02703
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDispatch-None-02704
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDispatch-None-02705
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDispatch-None-02706
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDispatch-commandBuffer-02707
If commandBuffer is an unprotected command buffer, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource
VUID-vkCmdDispatch-commandBuffer-02712
If commandBuffer is a protected command buffer, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource
VUID-vkCmdDispatch-commandBuffer-02713
If commandBuffer is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the VkPipeline object bound to the pipeline bind point must not write to any resource
VUID-vkCmdDispatch-groupCountX-00386
groupCountX must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]
VUID-vkCmdDispatch-groupCountY-00387
groupCountY must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]
VUID-vkCmdDispatch-groupCountZ-00388
groupCountZ must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]

Valid Usage (Implicit)

VUID-vkCmdDispatch-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdDispatch-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdDispatch-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support compute operations
VUID-vkCmdDispatch-renderpass
This command must only be called outside of a render pass instance

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Compute

To record an indirect command dispatch, call:

void vkCmdDispatchIndirect(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset);

commandBuffer is the command buffer into which the command will be recorded.
buffer is the buffer containing dispatch parameters.
offset is the byte offset into buffer where parameters begin.

vkCmdDispatchIndirect behaves similarly to vkCmdDispatch except that the parameters are read by the device from a buffer during execution. The parameters of the dispatch are encoded in a VkDispatchIndirectCommand structure taken from buffer starting at offset.

Valid Usage

VUID-vkCmdDispatchIndirect-None-02690
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
VUID-vkCmdDispatchIndirect-None-02691
If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
VUID-vkCmdDispatchIndirect-None-02692
If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT
VUID-vkCmdDispatchIndirect-filterCubic-02694
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDispatchIndirect-filterCubicMinmax-02695
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDispatchIndirect-flags-02696
Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.
VUID-vkCmdDispatchIndirect-None-02697
For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDispatchIndirect-None-02698
For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDispatchIndirect-None-02699
Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command
VUID-vkCmdDispatchIndirect-None-02700
A valid pipeline must be bound to the pipeline bind point used by this command
VUID-vkCmdDispatchIndirect-commandBuffer-02701
If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic
VUID-vkCmdDispatchIndirect-None-02859
There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound
VUID-vkCmdDispatchIndirect-None-02702
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
VUID-vkCmdDispatchIndirect-None-02703
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDispatchIndirect-None-02704
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDispatchIndirect-None-02705
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDispatchIndirect-None-02706
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDispatchIndirect-commandBuffer-02707
If commandBuffer is an unprotected command buffer, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource
VUID-vkCmdDispatchIndirect-buffer-02708
If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
VUID-vkCmdDispatchIndirect-buffer-02709
buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
VUID-vkCmdDispatchIndirect-offset-02710
offset must be a multiple of 4
VUID-vkCmdDispatchIndirect-commandBuffer-02711
commandBuffer must not be a protected command buffer
VUID-vkCmdDispatchIndirect-offset-00407
The sum of offset and the size of VkDispatchIndirectCommand must be less than or equal to the size of buffer

Valid Usage (Implicit)

VUID-vkCmdDispatchIndirect-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdDispatchIndirect-buffer-parameter
buffer must be a valid VkBuffer handle
VUID-vkCmdDispatchIndirect-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdDispatchIndirect-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support compute operations
VUID-vkCmdDispatchIndirect-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdDispatchIndirect-commonparent
Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Compute

The VkDispatchIndirectCommand structure is defined as:

typedef struct VkDispatchIndirectCommand {
    uint32_t    x;
    uint32_t    y;
    uint32_t    z;
} VkDispatchIndirectCommand;

x is the number of local workgroups to dispatch in the X dimension.
y is the number of local workgroups to dispatch in the Y dimension.
z is the number of local workgroups to dispatch in the Z dimension.

The members of VkDispatchIndirectCommand have the same meaning as the corresponding parameters of vkCmdDispatch.

Valid Usage

VUID-VkDispatchIndirectCommand-x-00417
x must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]
VUID-VkDispatchIndirectCommand-y-00418
y must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]
VUID-VkDispatchIndirectCommand-z-00419
z must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]

To record a dispatch using non-zero base values for the components of WorkgroupId, call:

void vkCmdDispatchBase(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    baseGroupX,
    uint32_t                                    baseGroupY,
    uint32_t                                    baseGroupZ,
    uint32_t                                    groupCountX,
    uint32_t                                    groupCountY,
    uint32_t                                    groupCountZ);

or the equivalent command

void vkCmdDispatchBaseKHR(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    baseGroupX,
    uint32_t                                    baseGroupY,
    uint32_t                                    baseGroupZ,
    uint32_t                                    groupCountX,
    uint32_t                                    groupCountY,
    uint32_t                                    groupCountZ);

commandBuffer is the command buffer into which the command will be recorded.
baseGroupX is the start value for the X component of WorkgroupId.
baseGroupY is the start value for the Y component of WorkgroupId.
baseGroupZ is the start value for the Z component of WorkgroupId.
groupCountX is the number of local workgroups to dispatch in the X dimension.
groupCountY is the number of local workgroups to dispatch in the Y dimension.
groupCountZ is the number of local workgroups to dispatch in the Z dimension.

When the command is executed, a global workgroup consisting of groupCountX × groupCountY × groupCountZ local workgroups is assembled, with WorkgroupId values ranging from [baseGroup*, baseGroup* + groupCount*) in each component. vkCmdDispatch is equivalent to vkCmdDispatchBase(0,0,0,groupCountX,groupCountY,groupCountZ).

Valid Usage

VUID-vkCmdDispatchBase-None-02690
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
VUID-vkCmdDispatchBase-None-02691
If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
VUID-vkCmdDispatchBase-None-02692
If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT
VUID-vkCmdDispatchBase-filterCubic-02694
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDispatchBase-filterCubicMinmax-02695
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdDispatchBase-flags-02696
Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.
VUID-vkCmdDispatchBase-None-02697
For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDispatchBase-None-02698
For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdDispatchBase-None-02699
Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command
VUID-vkCmdDispatchBase-None-02700
A valid pipeline must be bound to the pipeline bind point used by this command
VUID-vkCmdDispatchBase-commandBuffer-02701
If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic
VUID-vkCmdDispatchBase-None-02859
There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound
VUID-vkCmdDispatchBase-None-02702
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
VUID-vkCmdDispatchBase-None-02703
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDispatchBase-None-02704
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdDispatchBase-None-02705
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDispatchBase-None-02706
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdDispatchBase-commandBuffer-02707
If commandBuffer is an unprotected command buffer, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource
VUID-vkCmdDispatchBase-baseGroupX-00421
baseGroupX must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]
VUID-vkCmdDispatchBase-baseGroupX-00422
baseGroupX must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]
VUID-vkCmdDispatchBase-baseGroupZ-00423
baseGroupZ must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]
VUID-vkCmdDispatchBase-groupCountX-00424
groupCountX must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0] minus baseGroupX
VUID-vkCmdDispatchBase-groupCountY-00425
groupCountY must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1] minus baseGroupY
VUID-vkCmdDispatchBase-groupCountZ-00426
groupCountZ must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2] minus baseGroupZ
VUID-vkCmdDispatchBase-baseGroupX-00427
If any of baseGroupX, baseGroupY, or baseGroupZ are not zero, then the bound compute pipeline must have been created with the VK_PIPELINE_CREATE_DISPATCH_BASE flag.

Valid Usage (Implicit)

VUID-vkCmdDispatchBase-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdDispatchBase-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdDispatchBase-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support compute operations
VUID-vkCmdDispatchBase-renderpass
This command must only be called outside of a render pass instance

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Compute

30. Device-Generated Commands

This chapter discusses the generation of command buffer content on the device. These principle steps are to be taken to generate commands on the device:

Make resource bindings accessible for the device via registering in a VkObjectTableNVX.
Define via VkIndirectCommandsLayoutNVX the sequence of commands which should be generated.
Fill one or more VkBuffer with the appropriate content that gets interpreted by VkIndirectCommandsLayoutNVX.
Reserve command space via vkCmdReserveSpaceForCommandsNVX in a secondary VkCommandBuffer where the generated commands should be recorded.
Generate the actual commands via vkCmdProcessCommandsNVX passing all required data.

Execution of such generated commands can either be triggered directly with the generation process, or by executing the secondary VkCommandBuffer that was chosen as optional target. The latter allows re-using generated commands as well. Similar to VkDescriptorSet, special care should be taken for the lifetime of resources referenced in VkObjectTableNVX, which may be accessed at either generation or execution time.

vkCmdProcessCommandsNVX executes in a separate logical pipeline from either graphics or compute. When generating commands into a secondary command buffer, the command generation must be explicitly synchronized against the secondary command buffer’s execution. When not using a secondary command buffer, the command generation is automatically synchronized against the command execution.

30.1. Features and Limitations

To query the support of related features and limitations, call:

void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
    VkPhysicalDevice                            physicalDevice,
    VkDeviceGeneratedCommandsFeaturesNVX*       pFeatures,
    VkDeviceGeneratedCommandsLimitsNVX*         pLimits);

physicalDevice is the handle to the physical device whose properties will be queried.
pFeatures is a pointer to a VkDeviceGeneratedCommandsFeaturesNVX structure in which features are returned.
pLimits is a pointer to a VkDeviceGeneratedCommandsLimitsNVX structure in which limitations are returned.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-pFeatures-parameter
pFeatures must be a valid pointer to a VkDeviceGeneratedCommandsFeaturesNVX structure
VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-pLimits-parameter
pLimits must be a valid pointer to a VkDeviceGeneratedCommandsLimitsNVX structure

The VkDeviceGeneratedCommandsFeaturesNVX structure is defined as:

typedef struct VkDeviceGeneratedCommandsFeaturesNVX {
    VkStructureType    sType;
    const void*        pNext;
    VkBool32           computeBindingPointSupport;
} VkDeviceGeneratedCommandsFeaturesNVX;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
computeBindingPointSupport specifies whether the VkObjectTableNVX supports entries with VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX bit set and VkIndirectCommandsLayoutNVX supports VK_PIPELINE_BIND_POINT_COMPUTE.

Valid Usage (Implicit)

VUID-VkDeviceGeneratedCommandsFeaturesNVX-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX
VUID-VkDeviceGeneratedCommandsFeaturesNVX-pNext-pNext
pNext must be NULL

The VkDeviceGeneratedCommandsLimitsNVX structure is defined as:

typedef struct VkDeviceGeneratedCommandsLimitsNVX {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           maxIndirectCommandsLayoutTokenCount;
    uint32_t           maxObjectEntryCounts;
    uint32_t           minSequenceCountBufferOffsetAlignment;
    uint32_t           minSequenceIndexBufferOffsetAlignment;
    uint32_t           minCommandsTokenBufferOffsetAlignment;
} VkDeviceGeneratedCommandsLimitsNVX;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
maxIndirectCommandsLayoutTokenCount the maximum number of tokens in VkIndirectCommandsLayoutNVX.
maxObjectEntryCounts the maximum number of entries per resource type in VkObjectTableNVX.
minSequenceCountBufferOffsetAlignment the minimum alignment for memory addresses optionally used in vkCmdProcessCommandsNVX.
minSequenceIndexBufferOffsetAlignment the minimum alignment for memory addresses optionally used in vkCmdProcessCommandsNVX.
minCommandsTokenBufferOffsetAlignment the minimum alignment for memory addresses optionally used in vkCmdProcessCommandsNVX.

Valid Usage (Implicit)

VUID-VkDeviceGeneratedCommandsLimitsNVX-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX
VUID-VkDeviceGeneratedCommandsLimitsNVX-pNext-pNext
pNext must be NULL

30.2. Binding Object Table

The device-side bindings are registered inside a table:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX)

This is required as the CPU-side object pointers, for example when binding a VkPipeline or VkDescriptorSet, cannot be used by the device. The combination of VkObjectTableNVX and uint32_t table indices stored inside a VkBuffer serve that purpose during device command generation.

At creation time the table is defined with a fixed amount of registration slots for the individual resource types. A detailed resource binding can then later be registered via vkRegisterObjectsNVX at any uint32_t index below the allocated maximum.

30.2.1. Table Creation

To create object tables, call:

VkResult vkCreateObjectTableNVX(
    VkDevice                                    device,
    const VkObjectTableCreateInfoNVX*           pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkObjectTableNVX*                           pObjectTable);

device is the logical device that creates the object table.
pCreateInfo is a pointer to a VkObjectTableCreateInfoNVX structure containing parameters affecting creation of the table.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pObjectTable is a pointer to a VkObjectTableNVX handle in which the resulting object table is returned.

Valid Usage (Implicit)

VUID-vkCreateObjectTableNVX-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateObjectTableNVX-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkObjectTableCreateInfoNVX structure
VUID-vkCreateObjectTableNVX-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateObjectTableNVX-pObjectTable-parameter
pObjectTable must be a valid pointer to a VkObjectTableNVX handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkObjectTableCreateInfoNVX structure is defined as:

typedef struct VkObjectTableCreateInfoNVX {
    VkStructureType                      sType;
    const void*                          pNext;
    uint32_t                             objectCount;
    const VkObjectEntryTypeNVX*          pObjectEntryTypes;
    const uint32_t*                      pObjectEntryCounts;
    const VkObjectEntryUsageFlagsNVX*    pObjectEntryUsageFlags;
    uint32_t                             maxUniformBuffersPerDescriptor;
    uint32_t                             maxStorageBuffersPerDescriptor;
    uint32_t                             maxStorageImagesPerDescriptor;
    uint32_t                             maxSampledImagesPerDescriptor;
    uint32_t                             maxPipelineLayouts;
} VkObjectTableCreateInfoNVX;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
objectCount is the number of entry configurations that the object table supports.
pObjectEntryTypes is a pointer to an array of VkObjectEntryTypeNVX values providing the entry type of a given configuration.
pObjectEntryCounts is a pointer to an array of counts of how many objects can be registered in the table.
pObjectEntryUsageFlags is a pointer to an array of bitmasks of VkObjectEntryUsageFlagBitsNVX specifying the binding usage of the entry.
maxUniformBuffersPerDescriptor is the maximum number of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC used by any single registered VkDescriptorSet in this table.
maxStorageBuffersPerDescriptor is the maximum number of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC used by any single registered VkDescriptorSet in this table.
maxStorageImagesPerDescriptor is the maximum number of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER used by any single registered VkDescriptorSet in this table.
maxSampledImagesPerDescriptor is the maximum number of VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT used by any single registered VkDescriptorSet in this table.
maxPipelineLayouts is the maximum number of unique VkPipelineLayout used by any registered VkDescriptorSet or VkPipeline in this table.

Valid Usage

VUID-VkObjectTableCreateInfoNVX-computeBindingPointSupport-01355
If the VkDeviceGeneratedCommandsFeaturesNVX::computeBindingPointSupport feature is not enabled, pObjectEntryUsageFlags must not contain VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX
VUID-VkObjectTableCreateInfoNVX-pObjectEntryCounts-01356
Any value within pObjectEntryCounts must not exceed VkDeviceGeneratedCommandsLimitsNVX::maxObjectEntryCounts
VUID-VkObjectTableCreateInfoNVX-maxUniformBuffersPerDescriptor-01357
maxUniformBuffersPerDescriptor must be within the limits supported by the device.
VUID-VkObjectTableCreateInfoNVX-maxStorageBuffersPerDescriptor-01358
maxStorageBuffersPerDescriptor must be within the limits supported by the device.
VUID-VkObjectTableCreateInfoNVX-maxStorageImagesPerDescriptor-01359
maxStorageImagesPerDescriptor must be within the limits supported by the device.
VUID-VkObjectTableCreateInfoNVX-maxSampledImagesPerDescriptor-01360
maxSampledImagesPerDescriptor must be within the limits supported by the device.

Valid Usage (Implicit)

VUID-VkObjectTableCreateInfoNVX-sType-sType
sType must be VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX
VUID-VkObjectTableCreateInfoNVX-pNext-pNext
pNext must be NULL
VUID-VkObjectTableCreateInfoNVX-pObjectEntryTypes-parameter
pObjectEntryTypes must be a valid pointer to an array of objectCount valid VkObjectEntryTypeNVX values
VUID-VkObjectTableCreateInfoNVX-pObjectEntryCounts-parameter
pObjectEntryCounts must be a valid pointer to an array of objectCount uint32_t values
VUID-VkObjectTableCreateInfoNVX-pObjectEntryUsageFlags-parameter
pObjectEntryUsageFlags must be a valid pointer to an array of objectCount valid combinations of VkObjectEntryUsageFlagBitsNVX values
VUID-VkObjectTableCreateInfoNVX-pObjectEntryUsageFlags-requiredbitmask
Each element of pObjectEntryUsageFlags must not be 0
VUID-VkObjectTableCreateInfoNVX-objectCount-arraylength
objectCount must be greater than 0

Possible values of elements of the VkObjectTableCreateInfoNVX::pObjectEntryTypes array, specifying the entry type of a configuration, are:

typedef enum VkObjectEntryTypeNVX {
    VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0,
    VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = 1,
    VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = 2,
    VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = 3,
    VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = 4,
    VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
} VkObjectEntryTypeNVX;

VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX specifies a VkDescriptorSet resource entry that is registered via VkObjectTableDescriptorSetEntryNVX.
VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX specifies a VkPipeline resource entry that is registered via VkObjectTablePipelineEntryNVX.
VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX specifies a VkBuffer resource entry that is registered via VkObjectTableIndexBufferEntryNVX.
VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX specifies a VkBuffer resource entry that is registered via VkObjectTableVertexBufferEntryNVX.
VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX specifies the resource entry is registered via VkObjectTablePushConstantEntryNVX.

Bits which can be set in elements of the VkObjectTableCreateInfoNVX::pObjectEntryUsageFlags array, specifying binding usage of an entry, are:

typedef enum VkObjectEntryUsageFlagBitsNVX {
    VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001,
    VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002,
    VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
} VkObjectEntryUsageFlagBitsNVX;

VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX specifies that the resource is bound to VK_PIPELINE_BIND_POINT_GRAPHICS
VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX specifies that the resource is bound to VK_PIPELINE_BIND_POINT_COMPUTE

typedef VkFlags VkObjectEntryUsageFlagsNVX;

VkObjectEntryUsageFlagsNVX is a bitmask type for setting a mask of zero or more VkObjectEntryUsageFlagBitsNVX.

To destroy an object table, call:

void vkDestroyObjectTableNVX(
    VkDevice                                    device,
    VkObjectTableNVX                            objectTable,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the table.
objectTable is the table to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyObjectTableNVX-objectTable-01361
All submitted commands that refer to objectTable must have completed execution.
VUID-vkDestroyObjectTableNVX-objectTable-01362
If VkAllocationCallbacks were provided when objectTable was created, a compatible set of callbacks must be provided here.
VUID-vkDestroyObjectTableNVX-objectTable-01363
If no VkAllocationCallbacks were provided when objectTable was created, pAllocator must be NULL.

Valid Usage (Implicit)

VUID-vkDestroyObjectTableNVX-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyObjectTableNVX-objectTable-parameter
objectTable must be a valid VkObjectTableNVX handle
VUID-vkDestroyObjectTableNVX-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyObjectTableNVX-objectTable-parent
objectTable must have been created, allocated, or retrieved from device

Host Synchronization

Host access to objectTable must be externally synchronized

30.2.2. Registering Objects

Resource bindings of Vulkan objects are registered at an arbitrary uint32_t index within an object table. As long as the object table references such objects, they must not be deleted.

VkResult vkRegisterObjectsNVX(
    VkDevice                                    device,
    VkObjectTableNVX                            objectTable,
    uint32_t                                    objectCount,
    const VkObjectTableEntryNVX* const*         ppObjectTableEntries,
    const uint32_t*                             pObjectIndices);

device is the logical device that creates the object table.
objectTable is the table for which the resources are registered.
objectCount is the number of resources to register.
ppObjectTableEntries provides an array for detailed binding informations. Each array element is a pointer to a structure of type VkObjectTablePipelineEntryNVX, VkObjectTableDescriptorSetEntryNVX, VkObjectTableVertexBufferEntryNVX, VkObjectTableIndexBufferEntryNVX or VkObjectTablePushConstantEntryNVX (see below for details).
pObjectIndices are the indices at which each resource is registered.

Valid Usage

VUID-vkRegisterObjectsNVX-pObjectTableEntry-01364
The contents of pObjectTableEntry must yield plausible bindings supported by the device.
VUID-vkRegisterObjectsNVX-pObjectIndices-01365
At any pObjectIndices there must not be a registered resource already.
VUID-vkRegisterObjectsNVX-pObjectIndices-01366
Any value inside pObjectIndices must be below the appropriate VkObjectTableCreateInfoNVX::pObjectEntryCounts limits provided at objectTable creation time.

Valid Usage (Implicit)

VUID-vkRegisterObjectsNVX-device-parameter
device must be a valid VkDevice handle
VUID-vkRegisterObjectsNVX-objectTable-parameter
objectTable must be a valid VkObjectTableNVX handle
VUID-vkRegisterObjectsNVX-ppObjectTableEntries-parameter
ppObjectTableEntries must be a valid pointer to an array of objectCount valid VkObjectTableEntryNVX structures
VUID-vkRegisterObjectsNVX-pObjectIndices-parameter
pObjectIndices must be a valid pointer to an array of objectCount uint32_t values
VUID-vkRegisterObjectsNVX-objectCount-arraylength
objectCount must be greater than 0
VUID-vkRegisterObjectsNVX-objectTable-parent
objectTable must have been created, allocated, or retrieved from device

Host Synchronization

Host access to objectTable must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Common to all resource entries are:

typedef struct VkObjectTableEntryNVX {
    VkObjectEntryTypeNVX          type;
    VkObjectEntryUsageFlagsNVX    flags;
} VkObjectTableEntryNVX;

type defines the entry type
flags defines which VkPipelineBindPoint the resource can be used with. Some entry types allow only a single flag to be set.

Valid Usage

VUID-VkObjectTableEntryNVX-computeBindingPointSupport-01367
If the VkDeviceGeneratedCommandsFeaturesNVX::computeBindingPointSupport feature is not enabled, flags must not contain VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX

Valid Usage (Implicit)

VUID-VkObjectTableEntryNVX-type-parameter
type must be a valid VkObjectEntryTypeNVX value
VUID-VkObjectTableEntryNVX-flags-parameter
flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values
VUID-VkObjectTableEntryNVX-flags-requiredbitmask
flags must not be 0

typedef struct VkObjectTablePipelineEntryNVX {
    VkObjectEntryTypeNVX          type;
    VkObjectEntryUsageFlagsNVX    flags;
    VkPipeline                    pipeline;
} VkObjectTablePipelineEntryNVX;

pipeline specifies the VkPipeline that this resource entry references.

Valid Usage

VUID-VkObjectTablePipelineEntryNVX-type-01368
type must be VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX

Valid Usage (Implicit)

VUID-VkObjectTablePipelineEntryNVX-type-parameter
type must be a valid VkObjectEntryTypeNVX value
VUID-VkObjectTablePipelineEntryNVX-flags-parameter
flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values
VUID-VkObjectTablePipelineEntryNVX-flags-requiredbitmask
flags must not be 0
VUID-VkObjectTablePipelineEntryNVX-pipeline-parameter
pipeline must be a valid VkPipeline handle

typedef struct VkObjectTableDescriptorSetEntryNVX {
    VkObjectEntryTypeNVX          type;
    VkObjectEntryUsageFlagsNVX    flags;
    VkPipelineLayout              pipelineLayout;
    VkDescriptorSet               descriptorSet;
} VkObjectTableDescriptorSetEntryNVX;

pipelineLayout specifies the VkPipelineLayout that the descriptorSet is used with.
descriptorSet specifies the VkDescriptorSet that can be bound with this entry.

Valid Usage

VUID-VkObjectTableDescriptorSetEntryNVX-type-01369
type must be VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX

Valid Usage (Implicit)

VUID-VkObjectTableDescriptorSetEntryNVX-type-parameter
type must be a valid VkObjectEntryTypeNVX value
VUID-VkObjectTableDescriptorSetEntryNVX-flags-parameter
flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values
VUID-VkObjectTableDescriptorSetEntryNVX-flags-requiredbitmask
flags must not be 0
VUID-VkObjectTableDescriptorSetEntryNVX-pipelineLayout-parameter
pipelineLayout must be a valid VkPipelineLayout handle
VUID-VkObjectTableDescriptorSetEntryNVX-descriptorSet-parameter
descriptorSet must be a valid VkDescriptorSet handle
VUID-VkObjectTableDescriptorSetEntryNVX-commonparent
Both of descriptorSet, and pipelineLayout must have been created, allocated, or retrieved from the same VkDevice

typedef struct VkObjectTableVertexBufferEntryNVX {
    VkObjectEntryTypeNVX          type;
    VkObjectEntryUsageFlagsNVX    flags;
    VkBuffer                      buffer;
} VkObjectTableVertexBufferEntryNVX;

buffer specifies the VkBuffer that can be bound as vertex bufer

Valid Usage

VUID-VkObjectTableVertexBufferEntryNVX-type-01370
type must be VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX

Valid Usage (Implicit)

VUID-VkObjectTableVertexBufferEntryNVX-type-parameter
type must be a valid VkObjectEntryTypeNVX value
VUID-VkObjectTableVertexBufferEntryNVX-flags-parameter
flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values
VUID-VkObjectTableVertexBufferEntryNVX-flags-requiredbitmask
flags must not be 0
VUID-VkObjectTableVertexBufferEntryNVX-buffer-parameter
buffer must be a valid VkBuffer handle

typedef struct VkObjectTableIndexBufferEntryNVX {
    VkObjectEntryTypeNVX          type;
    VkObjectEntryUsageFlagsNVX    flags;
    VkBuffer                      buffer;
    VkIndexType                   indexType;
} VkObjectTableIndexBufferEntryNVX;

buffer specifies the VkBuffer that can be bound as index buffer
indexType specifies the VkIndexType used with this index buffer

Valid Usage

VUID-VkObjectTableIndexBufferEntryNVX-type-01371
type must be VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX
VUID-VkObjectTableIndexBufferEntryNVX-indexType-02783
indexType must be VK_INDEX_TYPE_UINT16, or VK_INDEX_TYPE_UINT32

Valid Usage (Implicit)

VUID-VkObjectTableIndexBufferEntryNVX-type-parameter
type must be a valid VkObjectEntryTypeNVX value
VUID-VkObjectTableIndexBufferEntryNVX-flags-parameter
flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values
VUID-VkObjectTableIndexBufferEntryNVX-flags-requiredbitmask
flags must not be 0
VUID-VkObjectTableIndexBufferEntryNVX-buffer-parameter
buffer must be a valid VkBuffer handle
VUID-VkObjectTableIndexBufferEntryNVX-indexType-parameter
indexType must be a valid VkIndexType value

typedef struct VkObjectTablePushConstantEntryNVX {
    VkObjectEntryTypeNVX          type;
    VkObjectEntryUsageFlagsNVX    flags;
    VkPipelineLayout              pipelineLayout;
    VkShaderStageFlags            stageFlags;
} VkObjectTablePushConstantEntryNVX;

pipelineLayout specifies the VkPipelineLayout that the pushconstants are used with
stageFlags specifies the VkShaderStageFlags that the pushconstants are used with

Valid Usage

VUID-VkObjectTablePushConstantEntryNVX-type-01372
type must be VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX

Valid Usage (Implicit)

VUID-VkObjectTablePushConstantEntryNVX-type-parameter
type must be a valid VkObjectEntryTypeNVX value
VUID-VkObjectTablePushConstantEntryNVX-flags-parameter
flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values
VUID-VkObjectTablePushConstantEntryNVX-flags-requiredbitmask
flags must not be 0
VUID-VkObjectTablePushConstantEntryNVX-pipelineLayout-parameter
pipelineLayout must be a valid VkPipelineLayout handle
VUID-VkObjectTablePushConstantEntryNVX-stageFlags-parameter
stageFlags must be a valid combination of VkShaderStageFlagBits values
VUID-VkObjectTablePushConstantEntryNVX-stageFlags-requiredbitmask
stageFlags must not be 0

Use the following command to unregister resources from an object table:

VkResult vkUnregisterObjectsNVX(
    VkDevice                                    device,
    VkObjectTableNVX                            objectTable,
    uint32_t                                    objectCount,
    const VkObjectEntryTypeNVX*                 pObjectEntryTypes,
    const uint32_t*                             pObjectIndices);

device is the logical device that creates the object table.
objectTable is the table from which the resources are unregistered.
objectCount is the number of resources being removed from the object table.
pObjectEntryType provides an array of VkObjectEntryTypeNVX for the resources being removed.
pObjectIndices provides the array of object indices to be removed.

Valid Usage

VUID-vkUnregisterObjectsNVX-pObjectIndices-01373
At any pObjectIndices there must be a registered resource already.
VUID-vkUnregisterObjectsNVX-pObjectEntryTypes-01374
The pObjectEntryTypes of the resource at pObjectIndices must match.
VUID-vkUnregisterObjectsNVX-None-01375
All operations on the device using the registered resource must have been completed.

Valid Usage (Implicit)

VUID-vkUnregisterObjectsNVX-device-parameter
device must be a valid VkDevice handle
VUID-vkUnregisterObjectsNVX-objectTable-parameter
objectTable must be a valid VkObjectTableNVX handle
VUID-vkUnregisterObjectsNVX-pObjectEntryTypes-parameter
pObjectEntryTypes must be a valid pointer to an array of objectCount valid VkObjectEntryTypeNVX values
VUID-vkUnregisterObjectsNVX-pObjectIndices-parameter
pObjectIndices must be a valid pointer to an array of objectCount uint32_t values
VUID-vkUnregisterObjectsNVX-objectCount-arraylength
objectCount must be greater than 0
VUID-vkUnregisterObjectsNVX-objectTable-parent
objectTable must have been created, allocated, or retrieved from device

Host Synchronization

Host access to objectTable must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

30.3. Indirect Commands Layout

The device-side command generation happens through an iterative processing of an atomic sequence comprised of command tokens, which are represented by:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX)

30.3.1. Tokenized Command Processing

The processing is in principle illustrated below:

void cmdProcessSequence(cmd, objectTable, indirectCommandsLayout, pIndirectCommandsTokens, s)
{
  for (c = 0; c < indirectCommandsLayout.tokenCount; c++)
  {
    indirectCommandsLayout.pTokens[c].command (cmd, objectTable, pIndirectCommandsTokens[c], s);
  }
}

void cmdProcessAllSequences(cmd, objectTable, indirectCommandsLayout, pIndirectCommandsTokens, sequencesCount)
{
  for (s = 0; s < sequencesCount; s++)
  {
    cmdProcessSequence(cmd, objectTable, indirectCommandsLayout, pIndirectCommandsTokens, s);
  }
}

The processing of each sequence is considered stateless, therefore all state changes must occur prior work provoking commands within the sequence. A single sequence is either strictly targeting VK_PIPELINE_BIND_POINT_GRAPHICS or VK_PIPELINE_BIND_POINT_COMPUTE.

The primary input data for each token is provided through VkBuffer content at command generation time using vkCmdProcessCommandsNVX, however some functional arguments, for example binding sets, are specified at layout creation time. The input size is different for each token.

Possible values of those elements of the VkIndirectCommandsLayoutCreateInfoNVX::pTokens array which specify command tokens (other elements of the array specify command parameters) are:

typedef enum VkIndirectCommandsTokenTypeNVX {
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = 0,
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1,
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = 2,
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = 3,
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = 4,
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = 5,
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = 6,
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = 7,
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
} VkIndirectCommandsTokenTypeNVX;

Table 39. Supported indirect command tokens
Token type	Equivalent command
`VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX`	`vkCmdBindPipeline`
`VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX`	`vkCmdBindDescriptorSets`
`VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX`	`vkCmdBindIndexBuffer`
`VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX`	`vkCmdBindVertexBuffers`
`VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX`	`vkCmdPushConstants`
`VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX`	`vkCmdDrawIndexedIndirect`
`VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX`	`vkCmdDrawIndirect`
`VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX`	`vkCmdDispatchIndirect`

The VkIndirectCommandsLayoutTokenNVX structure specifies details to the function arguments that need to be known at layout creation time:

typedef struct VkIndirectCommandsLayoutTokenNVX {
    VkIndirectCommandsTokenTypeNVX    tokenType;
    uint32_t                          bindingUnit;
    uint32_t                          dynamicCount;
    uint32_t                          divisor;
} VkIndirectCommandsLayoutTokenNVX;

type specifies the token command type.
bindingUnit has a different meaning depending on the type, please refer pseudo code further down for details.
dynamicCount has a different meaning depending on the type, please refer pseudo code further down for details.
divisor defines the rate at which the input data buffers are accessed.

Valid Usage

VUID-VkIndirectCommandsLayoutTokenNVX-bindingUnit-01342
bindingUnit must stay within device supported limits for the appropriate commands.
VUID-VkIndirectCommandsLayoutTokenNVX-dynamicCount-01343
dynamicCount must stay within device supported limits for the appropriate commands.
VUID-VkIndirectCommandsLayoutTokenNVX-divisor-01344
divisor must be greater than 0 and a power of two.

Valid Usage (Implicit)

VUID-VkIndirectCommandsLayoutTokenNVX-tokenType-parameter
tokenType must be a valid VkIndirectCommandsTokenTypeNVX value

The VkIndirectCommandsTokenNVX structure specifies the input data for a token at processing time.

typedef struct VkIndirectCommandsTokenNVX {
    VkIndirectCommandsTokenTypeNVX    tokenType;
    VkBuffer                          buffer;
    VkDeviceSize                      offset;
} VkIndirectCommandsTokenNVX;

tokenType specifies the token command type.
buffer specifies the VkBuffer storing the functional arguments for each squence. These argumetns can be written by the device.
offset specified an offset into buffer where the arguments start.

Valid Usage

VUID-VkIndirectCommandsTokenNVX-buffer-01345
The buffer’s usage flag must have the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set.
VUID-VkIndirectCommandsTokenNVX-offset-01346
The offset must be aligned to VkDeviceGeneratedCommandsLimitsNVX::minCommandsTokenBufferOffsetAlignment.

Valid Usage (Implicit)

VUID-VkIndirectCommandsTokenNVX-tokenType-parameter
tokenType must be a valid VkIndirectCommandsTokenTypeNVX value
VUID-VkIndirectCommandsTokenNVX-buffer-parameter
buffer must be a valid VkBuffer handle

The following code provides detailed information on how an individual sequence is processed:

void cmdProcessSequence(cmd, objectTable, indirectCommandsLayout, pIndirectCommandsTokens, s)
{
  for (uint32_t c = 0; c < indirectCommandsLayout.tokenCount; c++){
    input   = pIndirectCommandsTokens[c];
    i       = s / indirectCommandsLayout.pTokens[c].divisor;

    switch(input.type){
      VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX:
        size_t    stride  = sizeof(uint32_t);
        uint32_t* data    = input.buffer.pointer( input.offset + stride * i );
        uint32_t  object  = data[0];

        vkCmdBindPipeline(cmd, indirectCommandsLayout.pipelineBindPoint,
          objectTable.pipelines[ object ].pipeline);
      break;

      VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX:
        size_t    stride  = sizeof(uint32_t) + sizeof(uint32_t) * indirectCommandsLayout.pTokens[c].dynamicCount;
        uint32_t* data    = input.buffer.pointer( input.offset + stride * i);
        uint32_t  object  = data[0];

        vkCmdBindDescriptorSets(cmd, indirectCommandsLayout.pipelineBindPoint,
          objectTable.descriptorsets[ object ].layout,
          indirectCommandsLayout.pTokens[ c ].bindingUnit,
          1, &objectTable.descriptorsets[ object ].descriptorSet,
          indirectCommandsLayout.pTokens[ c ].dynamicCount, data + 1);
      break;

      VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX:
        size_t    stride  = sizeof(uint32_t) + indirectCommandsLayout.pTokens[c].dynamicCount;
        uint32_t* data    = input.buffer.pointer( input.offset + stride * i );
        uint32_t  object  = data[0];

        vkCmdPushConstants(cmd,
          objectTable.pushconstants[ object ].layout,
          objectTable.pushconstants[ object ].stageFlags,
          indirectCommandsLayout.pTokens[ c ].bindingUnit, indirectCommandsLayout.pTokens[c].dynamicCount, data + 1);
      break;

      VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX:
        size_t   s tride  = sizeof(uint32_t) + sizeof(uint32_t) * indirectCommandsLayout.pTokens[c].dynamicCount;
        uint32_t* data    = input.buffer.pointer( input.offset + stride * i );
        uint32_t  object  = data[0];

        vkCmdBindIndexBuffer(cmd,
          objectTable.vertexbuffers[ object ].buffer,
          indirectCommandsLayout.pTokens[ c ].dynamicCount ? data[1] : 0,
          objectTable.vertexbuffers[ object ].indexType);
      break;

      VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX:
        size_t    stride  = sizeof(uint32_t) + sizeof(uint32_t) * indirectCommandsLayout.pTokens[c].dynamicCount;
        uint32_t* data    = input.buffer.pointer( input.offset + stride * i );
        uint32_t  object  = data[0];

        vkCmdBindVertexBuffers(cmd,
          indirectCommandsLayout.pTokens[ c ].bindingUnit, 1,
          &objectTable.vertexbuffers[ object ].buffer,
          indirectCommandsLayout.pTokens[ c ].dynamicCount ? data + 1 : {0}); // device size handled as uint32_t
      break;

      VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX:
        vkCmdDrawIndexedIndirect(cmd,
          input.buffer,
          sizeof(VkDrawIndexedIndirectCommand) * i + input.offset, 1, 0);
      break;

      VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX:
        vkCmdDrawIndirect(cmd,
          input.buffer,
          sizeof(VkDrawIndirectCommand) * i  + input.offset, 1, 0);
      break;

      VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX:
        vkCmdDispatchIndirect(cmd,
          input.buffer,
          sizeof(VkDispatchIndirectCommand) * i  + input.offset);
      break;
    }
  }
}

30.3.2. Creation and Deletion

Indirect command layouts are created by:

VkResult vkCreateIndirectCommandsLayoutNVX(
    VkDevice                                    device,
    const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkIndirectCommandsLayoutNVX*                pIndirectCommandsLayout);

device is the logical device that creates the indirect command layout.
pCreateInfo is a pointer to a VkIndirectCommandsLayoutCreateInfoNVX structure containing parameters affecting creation of the indirect command layout.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pIndirectCommandsLayout is a pointer to a VkIndirectCommandsLayoutNVX handle in which the resulting indirect command layout is returned.

Valid Usage (Implicit)

VUID-vkCreateIndirectCommandsLayoutNVX-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateIndirectCommandsLayoutNVX-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkIndirectCommandsLayoutCreateInfoNVX structure
VUID-vkCreateIndirectCommandsLayoutNVX-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateIndirectCommandsLayoutNVX-pIndirectCommandsLayout-parameter
pIndirectCommandsLayout must be a valid pointer to a VkIndirectCommandsLayoutNVX handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkIndirectCommandsLayoutCreateInfoNVX structure is defined as:

typedef struct VkIndirectCommandsLayoutCreateInfoNVX {
    VkStructureType                            sType;
    const void*                                pNext;
    VkPipelineBindPoint                        pipelineBindPoint;
    VkIndirectCommandsLayoutUsageFlagsNVX      flags;
    uint32_t                                   tokenCount;
    const VkIndirectCommandsLayoutTokenNVX*    pTokens;
} VkIndirectCommandsLayoutCreateInfoNVX;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
pipelineBindPoint is the VkPipelineBindPoint that this layout targets.
flags is a bitmask of VkIndirectCommandsLayoutUsageFlagBitsNVX specifying usage hints of this layout.
tokenCount is the length of the individual command sequnce.
pTokens is an array describing each command token in detail. See VkIndirectCommandsTokenTypeNVX and VkIndirectCommandsLayoutTokenNVX below for details.

The following code illustrates some of the key flags:

void cmdProcessAllSequences(cmd, objectTable, indirectCommandsLayout, pIndirectCommandsTokens, sequencesCount, indexbuffer, indexbufferoffset)
{
  for (s = 0; s < sequencesCount; s++)
  {
    sequence = s;

    if (indirectCommandsLayout.flags & VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX) {
      sequence = incoherent_implementation_dependent_permutation[ sequence ];
    }
    if (indirectCommandsLayout.flags & VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX) {
      sequence = indexbuffer.load_uint32( sequence * sizeof(uint32_t) + indexbufferoffset);
    }

    cmdProcessSequence( cmd, objectTable, indirectCommandsLayout, pIndirectCommandsTokens, sequence );
  }
}

Valid Usage

VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-01347
tokenCount must be greater than 0 and below VkDeviceGeneratedCommandsLimitsNVX::maxIndirectCommandsLayoutTokenCount
VUID-VkIndirectCommandsLayoutCreateInfoNVX-computeBindingPointSupport-01348
If the VkDeviceGeneratedCommandsFeaturesNVX::computeBindingPointSupport feature is not enabled, then pipelineBindPoint must not be VK_PIPELINE_BIND_POINT_COMPUTE
VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01349
If pTokens contains an entry of VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX it must be the first element of the array and there must be only a single element of such token type.
VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01350
All state binding tokens in pTokens must occur prior work provoking tokens (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX).
VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01351
The content of pTokens must include one single work provoking token that is compatible with the pipelineBindPoint.

Valid Usage (Implicit)

VUID-VkIndirectCommandsLayoutCreateInfoNVX-sType-sType
sType must be VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX
VUID-VkIndirectCommandsLayoutCreateInfoNVX-pNext-pNext
pNext must be NULL
VUID-VkIndirectCommandsLayoutCreateInfoNVX-pipelineBindPoint-parameter
pipelineBindPoint must be a valid VkPipelineBindPoint value
VUID-VkIndirectCommandsLayoutCreateInfoNVX-flags-parameter
flags must be a valid combination of VkIndirectCommandsLayoutUsageFlagBitsNVX values
VUID-VkIndirectCommandsLayoutCreateInfoNVX-flags-requiredbitmask
flags must not be 0
VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-parameter
pTokens must be a valid pointer to an array of tokenCount valid VkIndirectCommandsLayoutTokenNVX structures
VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-arraylength
tokenCount must be greater than 0

Bits which can be set in VkIndirectCommandsLayoutCreateInfoNVX::flags, specifying usage hints of an indirect command layout, are:

typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX {
    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001,
    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002,
    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004,
    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008,
    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
} VkIndirectCommandsLayoutUsageFlagBitsNVX;

VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX specifies that the processing of sequences can happen at an implementation-dependent order, which is not guaranteed to be coherent across multiple invocations.
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX specifies that there is likely a high difference between allocated number of sequences and actually used.
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX specifies that there are likely many draw or dispatch calls that are zero-sized (zero grid dimension, no primitives to render).
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX specifies that the input data for the sequences is not implicitly indexed from 0..sequencesUsed but a user provided VkBuffer encoding the index is provided.

typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX;

VkIndirectCommandsLayoutUsageFlagsNVX is a bitmask type for setting a mask of zero or more VkIndirectCommandsLayoutUsageFlagBitsNVX.

Indirect command layouts are destroyed by:

void vkDestroyIndirectCommandsLayoutNVX(
    VkDevice                                    device,
    VkIndirectCommandsLayoutNVX                 indirectCommandsLayout,
    const VkAllocationCallbacks*                pAllocator);

device is the logical device that destroys the layout.
indirectCommandsLayout is the table to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-01352
All submitted commands that refer to indirectCommandsLayout must have completed execution
VUID-vkDestroyIndirectCommandsLayoutNVX-objectTable-01353
If VkAllocationCallbacks were provided when objectTable was created, a compatible set of callbacks must be provided here
VUID-vkDestroyIndirectCommandsLayoutNVX-objectTable-01354
If no VkAllocationCallbacks were provided when objectTable was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyIndirectCommandsLayoutNVX-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-parameter
indirectCommandsLayout must be a valid VkIndirectCommandsLayoutNVX handle
VUID-vkDestroyIndirectCommandsLayoutNVX-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-parent
indirectCommandsLayout must have been created, allocated, or retrieved from device

30.4. Indirect Commands Generation

Command space for generated commands recorded into a secondary command buffer must be reserved by calling:

void vkCmdReserveSpaceForCommandsNVX(
    VkCommandBuffer                             commandBuffer,
    const VkCmdReserveSpaceForCommandsInfoNVX*  pReserveSpaceInfo);

commandBuffer is the secondary command buffer in which the space for device-generated commands is reserved.
pProcessCommandsInfo is a pointer to a VkCmdReserveSpaceForCommandsInfoNVX structure containing parameters affecting the reservation of command buffer space.

Valid Usage

VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-01329
The provided commandBuffer must not have had a prior space reservation since its creation or the last reset.
VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-01330
The state of the commandBuffer must be legal to execute all commands within the sequence provided by the indirectCommandsLayout member of pProcessCommandsInfo.

Valid Usage (Implicit)

VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdReserveSpaceForCommandsNVX-pReserveSpaceInfo-parameter
pReserveSpaceInfo must be a valid pointer to a valid VkCmdReserveSpaceForCommandsInfoNVX structure
VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
VUID-vkCmdReserveSpaceForCommandsNVX-renderpass
This command must only be called inside of a render pass instance
VUID-vkCmdReserveSpaceForCommandsNVX-bufferlevel
commandBuffer must be a secondary VkCommandBuffer

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Secondary

Inside

Graphics
Compute

typedef struct VkCmdReserveSpaceForCommandsInfoNVX {
    VkStructureType                sType;
    const void*                    pNext;
    VkObjectTableNVX               objectTable;
    VkIndirectCommandsLayoutNVX    indirectCommandsLayout;
    uint32_t                       maxSequencesCount;
} VkCmdReserveSpaceForCommandsInfoNVX;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
objectTable is the VkObjectTableNVX to be used for the generation process. Only registered objects at the time vkCmdReserveSpaceForCommandsNVX is called, will be taken into account for the reservation.
indirectCommandsLayout is the VkIndirectCommandsLayoutNVX that must also be used at generation time.
maxSequencesCount is the maximum number of sequences for which command buffer space will be reserved.

Valid Usage (Implicit)

VUID-VkCmdReserveSpaceForCommandsInfoNVX-sType-sType
sType must be VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX
VUID-VkCmdReserveSpaceForCommandsInfoNVX-pNext-pNext
pNext must be NULL
VUID-VkCmdReserveSpaceForCommandsInfoNVX-objectTable-parameter
objectTable must be a valid VkObjectTableNVX handle
VUID-VkCmdReserveSpaceForCommandsInfoNVX-indirectCommandsLayout-parameter
indirectCommandsLayout must be a valid VkIndirectCommandsLayoutNVX handle
VUID-VkCmdReserveSpaceForCommandsInfoNVX-commonparent
Both of indirectCommandsLayout, and objectTable must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to objectTable must be externally synchronized

The generated commands will behave as if they were recorded within the call to vkCmdReserveSpaceForCommandsNVX, that means they can inherit state defined in the command buffer prior this call. However, given the stateless nature of the generated sequences, they will not affect commands after the reserved space. Treat the state that can be affected by the provided VkIndirectCommandsLayoutNVX as undefined.

The actual generation on the device is handled with:

void vkCmdProcessCommandsNVX(
    VkCommandBuffer                             commandBuffer,
    const VkCmdProcessCommandsInfoNVX*          pProcessCommandsInfo);

commandBuffer is the primary command buffer in which the generation process takes space.
pProcessCommandsInfo is a pointer to a VkCmdProcessCommandsInfoNVX structure containing parameters affecting the processing of commands.

Valid Usage (Implicit)

VUID-vkCmdProcessCommandsNVX-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdProcessCommandsNVX-pProcessCommandsInfo-parameter
pProcessCommandsInfo must be a valid pointer to a valid VkCmdProcessCommandsInfoNVX structure
VUID-vkCmdProcessCommandsNVX-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdProcessCommandsNVX-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
VUID-vkCmdProcessCommandsNVX-renderpass
This command must only be called inside of a render pass instance

Host Synchronization

Host access to commandBuffer must be externally synchronized
Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Inside

Graphics
Compute

typedef struct VkCmdProcessCommandsInfoNVX {
    VkStructureType                      sType;
    const void*                          pNext;
    VkObjectTableNVX                     objectTable;
    VkIndirectCommandsLayoutNVX          indirectCommandsLayout;
    uint32_t                             indirectCommandsTokenCount;
    const VkIndirectCommandsTokenNVX*    pIndirectCommandsTokens;
    uint32_t                             maxSequencesCount;
    VkCommandBuffer                      targetCommandBuffer;
    VkBuffer                             sequencesCountBuffer;
    VkDeviceSize                         sequencesCountOffset;
    VkBuffer                             sequencesIndexBuffer;
    VkDeviceSize                         sequencesIndexOffset;
} VkCmdProcessCommandsInfoNVX;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
objectTable is the VkObjectTableNVX to be used for the generation process. Only registered objects at the time vkCmdReserveSpaceForCommandsNVX is called, will be taken into account for the reservation.
indirectCommandsLayout is the VkIndirectCommandsLayoutNVX that provides the command sequence to generate.
indirectCommandsTokenCount defines the number of input tokens used.
pIndirectCommandsTokens provides an array of VkIndirectCommandsTokenNVX that reference the input data for each token command.
maxSequencesCount is the maximum number of sequences for which command buffer space will be reserved. If sequencesCountBuffer is VK_NULL_HANDLE, this is also the actual number of sequences generated.
targetCommandBuffer can be the secondary VkCommandBuffer in which the commands should be recorded. If targetCommandBuffer is NULL an implicit reservation as well as execution takes place on the processing VkCommandBuffer.
sequencesCountBuffer can be VkBuffer from which the actual amount of sequences is sourced from as uint32_t value.
sequencesCountOffset is the byte offset into sequencesCountBuffer where the count value is stored.
sequencesIndexBuffer must be set if indirectCommandsLayout’s VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX is set and provides the used sequence indices as uint32_t array. Otherwise it must be VK_NULL_HANDLE.
sequencesIndexOffset is the byte offset into sequencesIndexBuffer where the index values start.

Valid Usage

VUID-VkCmdProcessCommandsInfoNVX-objectTable-01331
The provided objectTable must include all objects referenced by the generation process
VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsTokenCount-01332
indirectCommandsTokenCount must match the indirectCommandsLayout’s tokenCount
VUID-VkCmdProcessCommandsInfoNVX-tokenType-01333
The tokenType member of each entry in the pIndirectCommandsTokens array must match the values used at creation time of indirectCommandsLayout
VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01334
If targetCommandBuffer is provided, it must have reserved command space
VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01335
If targetCommandBuffer is provided, the objectTable must match the reservation’s objectTable and must have had all referenced objects registered at reservation time
VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01336
If targetCommandBuffer is provided, the indirectCommandsLayout must match the reservation’s indirectCommandsLayout
VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01337
If targetCommandBuffer is provided, the maxSequencesCount must not exceed the reservation’s maxSequencesCount
VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-01338
If sequencesCountBuffer is used, its usage flag must have the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-01339
If sequencesCountBuffer is used, sequencesCountOffset must be aligned to VkDeviceGeneratedCommandsLimitsNVX::minSequenceCountBufferOffsetAlignment
VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-01340
If sequencesIndexBuffer is used, its usage flag must have the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-01341
If sequencesIndexBuffer is used, sequencesIndexOffset must be aligned to VkDeviceGeneratedCommandsLimitsNVX::minSequenceIndexBufferOffsetAlignment

Valid Usage (Implicit)

VUID-VkCmdProcessCommandsInfoNVX-sType-sType
sType must be VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX
VUID-VkCmdProcessCommandsInfoNVX-pNext-pNext
pNext must be NULL
VUID-VkCmdProcessCommandsInfoNVX-objectTable-parameter
objectTable must be a valid VkObjectTableNVX handle
VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsLayout-parameter
indirectCommandsLayout must be a valid VkIndirectCommandsLayoutNVX handle
VUID-VkCmdProcessCommandsInfoNVX-pIndirectCommandsTokens-parameter
pIndirectCommandsTokens must be a valid pointer to an array of indirectCommandsTokenCount valid VkIndirectCommandsTokenNVX structures
VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-parameter
If targetCommandBuffer is not NULL, targetCommandBuffer must be a valid VkCommandBuffer handle
VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-parameter
If sequencesCountBuffer is not VK_NULL_HANDLE, sequencesCountBuffer must be a valid VkBuffer handle
VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-parameter
If sequencesIndexBuffer is not VK_NULL_HANDLE, sequencesIndexBuffer must be a valid VkBuffer handle
VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsTokenCount-arraylength
indirectCommandsTokenCount must be greater than 0
VUID-VkCmdProcessCommandsInfoNVX-commonparent
Each of indirectCommandsLayout, objectTable, sequencesCountBuffer, sequencesIndexBuffer, and targetCommandBuffer that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to objectTable must be externally synchronized
Host access to targetCommandBuffer must be externally synchronized

Referencing the functions defined in Indirect Commands Layout, vkCmdProcessCommandsNVX behaves as:

// For targetCommandBuffers the existing reservedSpace is reset & overwritten.

VkCommandBuffer cmd = targetCommandBuffer ?
      targetCommandBuffer.reservedSpace :
      commandBuffer;

uint32_t sequencesCount = sequencesCountBuffer ?
      min(maxSequencesCount, sequencesCountBuffer.load_uint32(sequencesCountOffset) :
      maxSequencesCount;


cmdProcessAllSequences(cmd, objectTable,
                       indirectCommandsLayout, pIndirectCommandsTokens,
                       sequencesCount,
                       sequencesIndexBuffer, sequencesIndexOffset);

// The stateful commands within indirectCommandsLayout will not
// affect the state of subsequent commands in the target
// command buffer (cmd)

Note

It is important to note that the state that may be affected through generated commands must be considered undefined for the commands following them. It is not possible to setup generated state and provoking work that uses this state outside of the generated sequence.

31. Sparse Resources

As documented in Resource Memory Association, VkBuffer and VkImage resources in Vulkan must be bound completely and contiguously to a single VkDeviceMemory object. This binding must be done before the resource is used, and the binding is immutable for the lifetime of the resource.

Sparse resources relax these restrictions and provide these additional features:

Sparse resources can be bound non-contiguously to one or more VkDeviceMemory allocations.
Sparse resources can be re-bound to different memory allocations over the lifetime of the resource.
Sparse resources can have descriptors generated and used orthogonally with memory binding commands.

31.1. Sparse Resource Features

Sparse resources have several features that must be enabled explicitly at resource creation time. The features are enabled by including bits in the flags parameter of VkImageCreateInfo or VkBufferCreateInfo. Each feature also has one or more corresponding feature enables specified in VkPhysicalDeviceFeatures.

Sparse binding is the base feature, and provides the following capabilities:
- Resources can be bound at some defined (sparse block) granularity.
- The entire resource must be bound to memory before use regardless of regions actually accessed.
- No specific mapping of image region to memory offset is defined, i.e. the location that each texel corresponds to in memory is implementation-dependent.
- Sparse buffers have a well-defined mapping of buffer range to memory range, where an offset into a range of the buffer that is bound to a single contiguous range of memory corresponds to an identical offset within that range of memory.
- Requested via the VK_IMAGE_CREATE_SPARSE_BINDING_BIT and VK_BUFFER_CREATE_SPARSE_BINDING_BIT bits.
- A sparse image created using VK_IMAGE_CREATE_SPARSE_BINDING_BIT (but not VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT) supports all formats that non-sparse usage supports, and supports both VK_IMAGE_TILING_OPTIMAL and VK_IMAGE_TILING_LINEAR tiling.
Sparse Residency builds on (and requires) the sparseBinding feature. It includes the following capabilities:
- Resources do not have to be completely bound to memory before use on the device.
- Images have a prescribed sparse image block layout, allowing specific rectangular regions of the image to be bound to specific offsets in memory allocations.
- Consistency of access to unbound regions of the resource is defined by the absence or presence of VkPhysicalDeviceSparseProperties::residencyNonResidentStrict. If this property is present, accesses to unbound regions of the resource are well defined and behave as if the data bound is populated with all zeros; writes are discarded. When this property is absent, accesses are considered safe, but reads will return undefined values.
- Requested via the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT and VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT bits.
- Sparse residency support is advertised on a finer grain via the following features:
  - sparseResidencyBuffer: Support for creating VkBuffer objects with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT.
  - sparseResidencyImage2D: Support for creating 2D single-sampled VkImage objects with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT.
  - sparseResidencyImage3D: Support for creating 3D VkImage objects with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT.
  - sparseResidency2Samples: Support for creating 2D VkImage objects with 2 samples and VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT.
  - sparseResidency4Samples: Support for creating 2D VkImage objects with 4 samples and VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT.
  - sparseResidency8Samples: Support for creating 2D VkImage objects with 8 samples and VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT.
  - sparseResidency16Samples: Support for creating 2D VkImage objects with 16 samples and VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT.
  Implementations supporting sparseResidencyImage2D are only required to support sparse 2D, single-sampled images. Support for sparse 3D and MSAA images is optional and can be enabled via sparseResidencyImage3D, sparseResidency2Samples, sparseResidency4Samples, sparseResidency8Samples, and sparseResidency16Samples.
- A sparse image created using VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT supports all non-compressed color formats with power-of-two element size that non-sparse usage supports. Additional formats may also be supported and can be queried via vkGetPhysicalDeviceSparseImageFormatProperties. VK_IMAGE_TILING_LINEAR tiling is not supported.
Sparse aliasing provides the following capability that can be enabled per resource:

Allows physical memory ranges to be shared between multiple locations in the same sparse resource or between multiple sparse resources, with each binding of a memory location observing a consistent interpretation of the memory contents.

See Sparse Memory Aliasing for more information.

31.2. Sparse Buffers and Fully-Resident Images

Both VkBuffer and VkImage objects created with the VK_IMAGE_CREATE_SPARSE_BINDING_BIT or VK_BUFFER_CREATE_SPARSE_BINDING_BIT bits can be thought of as a linear region of address space. In the VkImage case if VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT is not used, this linear region is entirely opaque, meaning that there is no application-visible mapping between texel location and memory offset.

Unless VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT or VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT are also used, the entire resource must be bound to one or more VkDeviceMemory objects before use.

31.2.1. Sparse Buffer and Fully-Resident Image Block Size

The sparse block size in bytes for sparse buffers and fully-resident images is reported as VkMemoryRequirements::alignment. alignment represents both the memory alignment requirement and the binding granularity (in bytes) for sparse resources.

31.3. Sparse Partially-Resident Buffers

VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT bit allow the buffer to be made only partially resident. Partially resident VkBuffer objects are allocated and bound identically to VkBuffer objects using only the VK_BUFFER_CREATE_SPARSE_BINDING_BIT feature. The only difference is the ability for some regions of the buffer to be unbound during device use.

31.4. Sparse Partially-Resident Images

VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT bit allow specific rectangular regions of the image called sparse image blocks to be bound to specific ranges of memory. This allows the application to manage residency at either image subresource or sparse image block granularity. Each image subresource (outside of the mip tail) starts on a sparse block boundary and has dimensions that are integer multiples of the corresponding dimensions of the sparse image block.

Note

Applications can use these types of images to control LOD based on total memory consumption. If memory pressure becomes an issue the application can unbind and disable specific mipmap levels of images without having to recreate resources or modify texel data of unaffected levels.

The application can also use this functionality to access subregions of the image in a “megatexture” fashion. The application can create a large image and only populate the region of the image that is currently being used in the scene.

31.4.1. Accessing Unbound Regions

The following member of VkPhysicalDeviceSparseProperties affects how data in unbound regions of sparse resources are handled by the implementation:

residencyNonResidentStrict

If this property is not present, reads of unbound regions of the image will return undefined values. Both reads and writes are still considered safe and will not affect other resources or populated regions of the image.

If this property is present, all reads of unbound regions of the image will behave as if the region was bound to memory populated with all zeros; writes will be discarded.

Formatted accesses to unbound memory may still alter some component values in the natural way for those accesses, e.g. substituting a value of one for alpha in formats that do not have an alpha component.

Example: Reading the alpha component of an unbacked VK_FORMAT_R8_UNORM image will return a value of 1.0f.

See Physical Device Enumeration for instructions for retrieving physical device properties.

Implementor’s Note

For implementations that cannot natively handle access to unbound regions of a resource, the implementation may allocate and bind memory to the unbound regions. Reads and writes to unbound regions will access the implementation-managed memory instead.

Given that the values resulting from reads of unbound regions are undefined in this scenario, implementations may use the same physical memory for all unbound regions of multiple resources within the same process.

31.4.2. Mip Tail Regions

Sparse images created using VK_IMAGE_CREATE_SPARSE_BINDING_BIT (without also using VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT) have no specific mapping of image region or image subresource to memory offset defined, so the entire image can be thought of as a linear opaque address region. However, images created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT do have a prescribed sparse image block layout, and hence each image subresource must start on a sparse block boundary. Within each array layer, the set of mip levels that have a smaller size than the sparse block size in bytes are grouped together into a mip tail region.

If the VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT flag is present in the flags member of VkSparseImageFormatProperties, for the image’s format, then any mip level which has dimensions that are not integer multiples of the corresponding dimensions of the sparse image block, and all subsequent mip levels, are also included in the mip tail region.

The following member of VkPhysicalDeviceSparseProperties may affect how the implementation places mip levels in the mip tail region:

residencyAlignedMipSize

Each mip tail region is bound to memory as an opaque region (i.e. must be bound using a VkSparseImageOpaqueMemoryBindInfo structure) and may be of a size greater than or equal to the sparse block size in bytes. This size is guaranteed to be an integer multiple of the sparse block size in bytes.

An implementation may choose to allow each array-layer’s mip tail region to be bound to memory independently or require that all array-layer’s mip tail regions be treated as one. This is dictated by VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT in VkSparseImageMemoryRequirements::flags.

The following diagrams depict how VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT and VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT alter memory usage and requirements.

Figure 19. Sparse Image

In the absence of VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT and VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT, each array layer contains a mip tail region containing texel data for all mip levels smaller than the sparse image block in any dimension.

Mip levels that are as large or larger than a sparse image block in all dimensions can be bound individually. Right-edges and bottom-edges of each level are allowed to have partially used sparse blocks. Any bound partially-used-sparse-blocks must still have their full sparse block size in bytes allocated in memory.

Figure 20. Sparse Image with Single Mip Tail

When VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT is present all array layers will share a single mip tail region.

Figure 21. Sparse Image with Aligned Mip Size

Note

The mip tail regions are presented here in 2D arrays simply for figure size reasons. Each mip tail is logically a single array of sparse blocks with an implementation-dependent mapping of texels or compressed texel blocks to sparse blocks.

When VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT is present the first mip level that would contain partially used sparse blocks begins the mip tail region. This level and all subsequent levels are placed in the mip tail. Only the first N mip levels whose dimensions are an exact multiple of the sparse image block dimensions can be bound and unbound on a sparse block basis.

Figure 22. Sparse Image with Aligned Mip Size and Single Mip Tail

Note

The mip tail region is presented here in a 2D array simply for figure size reasons. It is logically a single array of sparse blocks with an implementation-dependent mapping of texels or compressed texel blocks to sparse blocks.

When both VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT and VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT are present the constraints from each of these flags are in effect.

31.4.3. Standard Sparse Image Block Shapes

Standard sparse image block shapes define a standard set of dimensions for sparse image blocks that depend on the format of the image. Layout of texels or compressed texel blocks within a sparse image block is implementation dependent. All currently defined standard sparse image block shapes are 64 KB in size.

For block-compressed formats (e.g. VK_FORMAT_BC5_UNORM_BLOCK), the texel size is the size of the compressed texel block (e.g. 128-bit for BC5) thus the dimensions of the standard sparse image block shapes apply in terms of compressed texel blocks.

Note

For block-compressed formats, the dimensions of a sparse image block in terms of texels can be calculated by multiplying the sparse image block dimensions by the compressed texel block dimensions.

Table 40. Standard Sparse Image Block Shapes (Single Sample)
TEXEL SIZE (bits)	Block Shape (2D)	Block Shape (3D)
8-Bit	256 × 256 × 1	64 × 32 × 32
16-Bit	256 × 128 × 1	32 × 32 × 32
32-Bit	128 × 128 × 1	32 × 32 × 16
64-Bit	128 × 64 × 1	32 × 16 × 16
128-Bit	64 × 64 × 1	16 × 16 × 16

Table 41. Standard Sparse Image Block Shapes (MSAA)
TEXEL SIZE (bits)	Block Shape (2X)	Block Shape (4X)	Block Shape (8X)	Block Shape (16X)
8-Bit	128 × 256 × 1	128 × 128 × 1	64 × 128 × 1	64 × 64 × 1
16-Bit	128 × 128 × 1	128 × 64 × 1	64 × 64 × 1	64 × 32 × 1
32-Bit	64 × 128 × 1	64 × 64 × 1	32 × 64 × 1	32 × 32 × 1
64-Bit	64 × 64 × 1	64 × 32 × 1	32 × 32 × 1	32 × 16 × 1
128-Bit	32 × 64 × 1	32 × 32 × 1	16 × 32 × 1	16 × 16 × 1

Implementations that support the standard sparse image block shape for all formats listed in the Standard Sparse Image Block Shapes (Single Sample) and Standard Sparse Image Block Shapes (MSAA) tables may advertise the following VkPhysicalDeviceSparseProperties:

residencyStandard2DBlockShape
residencyStandard2DMultisampleBlockShape
residencyStandard3DBlockShape

Reporting each of these features does not imply that all possible image types are supported as sparse. Instead, this indicates that no supported sparse image of the corresponding type will use custom sparse image block dimensions for any formats that have a corresponding standard sparse image block shape.

31.4.4. Custom Sparse Image Block Shapes

An implementation that does not support a standard image block shape for a particular sparse partially-resident image may choose to support a custom sparse image block shape for it instead. The dimensions of such a custom sparse image block shape are reported in VkSparseImageFormatProperties::imageGranularity. As with standard sparse image block shapes, the size in bytes of the custom sparse image block shape will be reported in VkMemoryRequirements::alignment.

Custom sparse image block dimensions are reported through vkGetPhysicalDeviceSparseImageFormatProperties and vkGetImageSparseMemoryRequirements.

An implementation must not support both the standard sparse image block shape and a custom sparse image block shape for the same image. The standard sparse image block shape must be used if it is supported.

31.4.5. Multiple Aspects

Partially resident images are allowed to report separate sparse properties for different aspects of the image. One example is for depth/stencil images where the implementation separates the depth and stencil data into separate planes. Another reason for multiple aspects is to allow the application to manage memory allocation for implementation-private metadata associated with the image. See the figure below:

Figure 23. Multiple Aspect Sparse Image

Note

In the figure above the depth, stencil, and metadata aspects all have unique sparse properties. The per-texel stencil data is ¼ the size of the depth data, hence the stencil sparse blocks include 4 × the number of texels. The sparse block size in bytes for all of the aspects is identical and defined by VkMemoryRequirements::alignment.

Metadata

The metadata aspect of an image has the following constraints:

All metadata is reported in the mip tail region of the metadata aspect.
All metadata must be bound prior to device use of the sparse image.

31.5. Sparse Memory Aliasing

By default sparse resources have the same aliasing rules as non-sparse resources. See Memory Aliasing for more information.

VkDevice objects that have the sparseResidencyAliased feature enabled are able to use the VK_BUFFER_CREATE_SPARSE_ALIASED_BIT and VK_IMAGE_CREATE_SPARSE_ALIASED_BIT flags for resource creation. These flags allow resources to access physical memory bound into multiple locations within one or more sparse resources in a data consistent fashion. This means that reading physical memory from multiple aliased locations will return the same value.

Care must be taken when performing a write operation to aliased physical memory. Memory dependencies must be used to separate writes to one alias from reads or writes to another alias. Writes to aliased memory that are not properly guarded against accesses to different aliases will have undefined results for all accesses to the aliased memory.

Applications that wish to make use of data consistent sparse memory aliasing must abide by the following guidelines:

All sparse resources that are bound to aliased physical memory must be created with the VK_BUFFER_CREATE_SPARSE_ALIASED_BIT / VK_IMAGE_CREATE_SPARSE_ALIASED_BIT flag.
All resources that access aliased physical memory must interpret the memory in the same way. This implies the following:
- Buffers and images cannot alias the same physical memory in a data consistent fashion. The physical memory ranges must be used exclusively by buffers or used exclusively by images for data consistency to be guaranteed.
- Memory in sparse image mip tail regions cannot access aliased memory in a data consistent fashion.
- Sparse images that alias the same physical memory must have compatible formats and be using the same sparse image block shape in order to access aliased memory in a data consistent fashion.

Failure to follow any of the above guidelines will require the application to abide by the normal, non-sparse resource aliasing rules. In this case memory cannot be accessed in a data consistent fashion.

Note

Enabling sparse resource memory aliasing can be a way to lower physical memory use, but it may reduce performance on some implementations. An application developer can test on their target HW and balance the memory / performance trade-offs measured.

31.6. Sparse Resource Implementation Guidelines

This section is Informative. It is included to aid in implementors’ understanding of sparse resources.

Device Virtual Address

The basic sparseBinding feature allows the resource to reserve its own device virtual address range at resource creation time rather than relying on a bind operation to set this. Without any other creation flags, no other constraints are relaxed compared to normal resources. All pages must be bound to physical memory before the device accesses the resource.

The sparse residency features allow sparse resources to be used even when not all pages are bound to memory. Implementations that support access to unbound pages without causing a fault may support residencyNonResidentStrict.

Not faulting on access to unbound pages is not enough to support residencyNonResidentStrict. An implementation must also guarantee that reads after writes to unbound regions of the resource always return data for the read as if the memory contains zeros. Depending on any caching hierarchy of the implementation this may not always be possible.

Any implementation that does not fault, but does not guarantee correct read values must not support residencyNonResidentStrict.

Any implementation that cannot access unbound pages without causing a fault will require the implementation to bind the entire device virtual address range to physical memory. Any pages that the application does not bind to memory may be bound to one (or more) “dummy” physical page(s) allocated by the implementation. Given the following properties:

A process must not access memory from another process
Reads return undefined values

It is sufficient for each host process to allocate these dummy pages and use them for all resources in that process. Implementations may allocate more often (per instance, per device, or per resource).

Binding Memory

The byte size reported in VkMemoryRequirements::size must be greater than or equal to the amount of physical memory required to fully populate the resource. Some implementations require “holes” in the device virtual address range that are never accessed. These holes may be included in the size reported for the resource.

Including or not including the device virtual address holes in the resource size will alter how the implementation provides support for VkSparseImageOpaqueMemoryBindInfo. This operation must be supported for all sparse images, even ones created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT.

editing-note

@ntrevett suggested expanding the NOTE tag below to encompass everything from “The cost is…” in the first bullet point through the current note. TBD.

If the holes are included in the size, this bind function becomes very easy. In most cases the resourceOffset is simply a device virtual address offset and the implementation can easily determine what device virtual address to bind. The cost is that the application may allocate more physical memory for the resource than it needs.
If the holes are not included in the size, the application can allocate less physical memory than otherwise for the resource. However, in this case the implementation must account for the holes when mapping resourceOffset to the actual device virtual address intended to be mapped.

Note

If the application always uses VkSparseImageMemoryBindInfo to bind memory for the non-tail mip levels, any holes that are present in the resource size may never be bound.

Since VkSparseImageMemoryBindInfo uses texel locations to determine which device virtual addresses to bind, it is impossible to bind device virtual address holes with this operation.

Binding Metadata Memory

All metadata for sparse images have their own sparse properties and are embedded in the mip tail region for said properties. See the Multiaspect section for details.

Given that metadata is in a mip tail region, and the mip tail region must be reported as contiguous (either globally or per-array-layer), some implementations will have to resort to complicated offset → device virtual address mapping for handling VkSparseImageOpaqueMemoryBindInfo.

To make this easier on the implementation, the VK_SPARSE_MEMORY_BIND_METADATA_BIT explicitly specifies when metadata is bound with VkSparseImageOpaqueMemoryBindInfo. When this flag is not present, the resourceOffset may be treated as a strict device virtual address offset.

When VK_SPARSE_MEMORY_BIND_METADATA_BIT is present, the resourceOffset must have been derived explicitly from the imageMipTailOffset in the sparse resource properties returned for the metadata aspect. By manipulating the value returned for imageMipTailOffset, the resourceOffset does not have to correlate directly to a device virtual address offset, and may instead be whatever values makes it easiest for the implementation to derive the correct device virtual address.

31.7. Sparse Resource API

The APIs related to sparse resources are grouped into the following categories:

Physical Device Features
Physical Device Sparse Properties
Sparse Image Format Properties
Sparse Resource Creation
Sparse Resource Memory Requirements
Binding Resource Memory

31.7.1. Physical Device Features

Some sparse-resource related features are reported and enabled in VkPhysicalDeviceFeatures. These features must be supported and enabled on the VkDevice object before applications can use them. See Physical Device Features for information on how to get and set enabled device features, and for more detailed explanations of these features.

Sparse Physical Device Features

sparseBinding: Support for creating VkBuffer and VkImage objects with the VK_BUFFER_CREATE_SPARSE_BINDING_BIT and VK_IMAGE_CREATE_SPARSE_BINDING_BIT flags, respectively.
sparseResidencyBuffer: Support for creating VkBuffer objects with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag.
sparseResidencyImage2D: Support for creating 2D single-sampled VkImage objects with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT.
sparseResidencyImage3D: Support for creating 3D VkImage objects with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT.
sparseResidency2Samples: Support for creating 2D VkImage objects with 2 samples and VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT.
sparseResidency4Samples: Support for creating 2D VkImage objects with 4 samples and VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT.
sparseResidency8Samples: Support for creating 2D VkImage objects with 8 samples and VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT.
sparseResidency16Samples: Support for creating 2D VkImage objects with 16 samples and VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT.
sparseResidencyAliased: Support for creating VkBuffer and VkImage objects with the VK_BUFFER_CREATE_SPARSE_ALIASED_BIT and VK_IMAGE_CREATE_SPARSE_ALIASED_BIT flags, respectively.

31.7.2. Physical Device Sparse Properties

Some features of the implementation are not possible to disable, and are reported to allow applications to alter their sparse resource usage accordingly. These read-only capabilities are reported in the VkPhysicalDeviceProperties::sparseProperties member, which is a structure of type VkPhysicalDeviceSparseProperties.

The VkPhysicalDeviceSparseProperties structure is defined as:

typedef struct VkPhysicalDeviceSparseProperties {
    VkBool32    residencyStandard2DBlockShape;
    VkBool32    residencyStandard2DMultisampleBlockShape;
    VkBool32    residencyStandard3DBlockShape;
    VkBool32    residencyAlignedMipSize;
    VkBool32    residencyNonResidentStrict;
} VkPhysicalDeviceSparseProperties;

residencyStandard2DBlockShape is VK_TRUE if the physical device will access all single-sample 2D sparse resources using the standard sparse image block shapes (based on image format), as described in the Standard Sparse Image Block Shapes (Single Sample) table. If this property is not supported the value returned in the imageGranularity member of the VkSparseImageFormatProperties structure for single-sample 2D images is not required to match the standard sparse image block dimensions listed in the table.
residencyStandard2DMultisampleBlockShape is VK_TRUE if the physical device will access all multisample 2D sparse resources using the standard sparse image block shapes (based on image format), as described in the Standard Sparse Image Block Shapes (MSAA) table. If this property is not supported, the value returned in the imageGranularity member of the VkSparseImageFormatProperties structure for multisample 2D images is not required to match the standard sparse image block dimensions listed in the table.
residencyStandard3DBlockShape is VK_TRUE if the physical device will access all 3D sparse resources using the standard sparse image block shapes (based on image format), as described in the Standard Sparse Image Block Shapes (Single Sample) table. If this property is not supported, the value returned in the imageGranularity member of the VkSparseImageFormatProperties structure for 3D images is not required to match the standard sparse image block dimensions listed in the table.
residencyAlignedMipSize is VK_TRUE if images with mip level dimensions that are not integer multiples of the corresponding dimensions of the sparse image block may be placed in the mip tail. If this property is not reported, only mip levels with dimensions smaller than the imageGranularity member of the VkSparseImageFormatProperties structure will be placed in the mip tail. If this property is reported the implementation is allowed to return VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT in the flags member of VkSparseImageFormatProperties, indicating that mip level dimensions that are not integer multiples of the corresponding dimensions of the sparse image block will be placed in the mip tail.
residencyNonResidentStrict specifies whether the physical device can consistently access non-resident regions of a resource. If this property is VK_TRUE, access to non-resident regions of resources will be guaranteed to return values as if the resource were populated with 0; writes to non-resident regions will be discarded.

31.7.3. Sparse Image Format Properties

Given that certain aspects of sparse image support, including the sparse image block dimensions, 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 image block shape will be.

Sparse Image Format Properties API

The VkSparseImageFormatProperties structure is defined as:

typedef struct VkSparseImageFormatProperties {
    VkImageAspectFlags          aspectMask;
    VkExtent3D                  imageGranularity;
    VkSparseImageFormatFlags    flags;
} VkSparseImageFormatProperties;

aspectMask is a bitmask VkImageAspectFlagBits specifying which aspects of the image the properties apply to.
imageGranularity is the width, height, and depth of the sparse image block in texels or compressed texel blocks.
flags is a bitmask of VkSparseImageFormatFlagBits specifying additional information about the sparse resource.

Bits which may be set in VkSparseImageFormatProperties::flags, specifying additional information about the sparse resource, are:

typedef enum VkSparseImageFormatFlagBits {
    VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
    VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
    VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
    VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkSparseImageFormatFlagBits;

VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT specifies that the image uses a single mip tail region for all array layers.
VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT specifies that the first mip level whose dimensions are not integer multiples of the corresponding dimensions of the sparse image block begins the mip tail region.
VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT specifies that the image uses non-standard sparse image block dimensions, and the imageGranularity values do not match the standard sparse image block dimensions for the given format.

typedef VkFlags VkSparseImageFormatFlags;

VkSparseImageFormatFlags is a bitmask type for setting a mask of zero or more VkSparseImageFormatFlagBits.

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.

void vkGetPhysicalDeviceSparseImageFormatProperties(
    VkPhysicalDevice                            physicalDevice,
    VkFormat                                    format,
    VkImageType                                 type,
    VkSampleCountFlagBits                       samples,
    VkImageUsageFlags                           usage,
    VkImageTiling                               tiling,
    uint32_t*                                   pPropertyCount,
    VkSparseImageFormatProperties*              pProperties);

physicalDevice is the physical device from which to query the sparse image capabilities.
format is the image format.
type is the dimensionality of image.
samples is the number of samples per texel as defined in VkSampleCountFlagBits.
usage is a bitmask describing the intended usage of the image.
tiling is the tiling arrangement of the texel blocks in memory.
pPropertyCount is a pointer to an integer related to the number of sparse format properties available or queried, as described below.
pProperties is either NULL or a pointer to an array of VkSparseImageFormatProperties structures.

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.

If VK_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 VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT.

Valid Usage

VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-01094
samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, type, tiling, and usage equal to those in this command and flags equal to the value that is set in VkImageCreateInfo::flags when the image is created

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceSparseImageFormatProperties-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceSparseImageFormatProperties-format-parameter
format must be a valid VkFormat value
VUID-vkGetPhysicalDeviceSparseImageFormatProperties-type-parameter
type must be a valid VkImageType value
VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-parameter
samples must be a valid VkSampleCountFlagBits value
VUID-vkGetPhysicalDeviceSparseImageFormatProperties-usage-parameter
usage must be a valid combination of VkImageUsageFlagBits values
VUID-vkGetPhysicalDeviceSparseImageFormatProperties-usage-requiredbitmask
usage must not be 0
VUID-vkGetPhysicalDeviceSparseImageFormatProperties-tiling-parameter
tiling must be a valid VkImageTiling value
VUID-vkGetPhysicalDeviceSparseImageFormatProperties-pPropertyCount-parameter
pPropertyCount must be a valid pointer to a uint32_t value
VUID-vkGetPhysicalDeviceSparseImageFormatProperties-pProperties-parameter
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkSparseImageFormatProperties structures

vkGetPhysicalDeviceSparseImageFormatProperties2 returns an array of VkSparseImageFormatProperties2. Each element will describe properties for one set of image aspects that are bound simultaneously in the image. This is usually one element for each aspect in the image, but for interleaved depth/stencil images there is only one element describing the combined aspects.

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

or the equivalent command

void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
    uint32_t*                                   pPropertyCount,
    VkSparseImageFormatProperties2*             pProperties);

physicalDevice is the physical device from which to query the sparse image capabilities.
pFormatInfo is a pointer to a VkPhysicalDeviceSparseImageFormatInfo2 structure containing input parameters to the command.
pPropertyCount is a pointer to an integer related to the number of sparse format properties available or queried, as described below.
pProperties is either NULL or a pointer to an array of VkSparseImageFormatProperties2 structures.

vkGetPhysicalDeviceSparseImageFormatProperties2 behaves identically to vkGetPhysicalDeviceSparseImageFormatProperties, with the ability to return extended information by adding extension structures to the pNext chain of its pProperties parameter.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pFormatInfo-parameter
pFormatInfo must be a valid pointer to a valid VkPhysicalDeviceSparseImageFormatInfo2 structure
VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pPropertyCount-parameter
pPropertyCount must be a valid pointer to a uint32_t value
VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pProperties-parameter
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkSparseImageFormatProperties2 structures

The VkPhysicalDeviceSparseImageFormatInfo2 structure is defined as:

typedef struct VkPhysicalDeviceSparseImageFormatInfo2 {
    VkStructureType          sType;
    const void*              pNext;
    VkFormat                 format;
    VkImageType              type;
    VkSampleCountFlagBits    samples;
    VkImageUsageFlags        usage;
    VkImageTiling            tiling;
} VkPhysicalDeviceSparseImageFormatInfo2;

or the equivalent

typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
format is the image format.
type is the dimensionality of image.
samples is the number of samples per texel as defined in VkSampleCountFlagBits.
usage is a bitmask describing the intended usage of the image.
tiling is the tiling arrangement of the texel blocks in memory.

Valid Usage

VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-01095
samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, type, tiling, and usage equal to those in this command and flags equal to the value that is set in VkImageCreateInfo::flags when the image is created

Valid Usage (Implicit)

VUID-VkPhysicalDeviceSparseImageFormatInfo2-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2
VUID-VkPhysicalDeviceSparseImageFormatInfo2-pNext-pNext
pNext must be NULL
VUID-VkPhysicalDeviceSparseImageFormatInfo2-format-parameter
format must be a valid VkFormat value
VUID-VkPhysicalDeviceSparseImageFormatInfo2-type-parameter
type must be a valid VkImageType value
VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-parameter
samples must be a valid VkSampleCountFlagBits value
VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-parameter
usage must be a valid combination of VkImageUsageFlagBits values
VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-requiredbitmask
usage must not be 0
VUID-VkPhysicalDeviceSparseImageFormatInfo2-tiling-parameter
tiling must be a valid VkImageTiling value

The VkSparseImageFormatProperties2 structure is defined as:

typedef struct VkSparseImageFormatProperties2 {
    VkStructureType                  sType;
    void*                            pNext;
    VkSparseImageFormatProperties    properties;
} VkSparseImageFormatProperties2;

or the equivalent

typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
properties is a VkSparseImageFormatProperties structure which is populated with the same values as in vkGetPhysicalDeviceSparseImageFormatProperties.

Valid Usage (Implicit)

VUID-VkSparseImageFormatProperties2-sType-sType
sType must be VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2
VUID-VkSparseImageFormatProperties2-pNext-pNext
pNext must be NULL

31.7.4. Sparse Resource Creation

Sparse resources require that one or more sparse feature flags be specified (as part of the VkPhysicalDeviceFeatures structure described previously in the Physical Device Features section) at CreateDevice time. When the appropriate device features are enabled, the VK_BUFFER_CREATE_SPARSE_* and VK_IMAGE_CREATE_SPARSE_* flags can be used. See vkCreateBuffer and vkCreateImage for details of the resource creation APIs.

Note

Specifying VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT or VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT requires specifying VK_BUFFER_CREATE_SPARSE_BINDING_BIT or VK_IMAGE_CREATE_SPARSE_BINDING_BIT, respectively, as well. This means that resources must be created with the appropriate *_SPARSE_BINDING_BIT to be used with the sparse binding command (vkQueueBindSparse).

31.7.5. Sparse Resource Memory Requirements

Sparse resources have specific memory requirements related to binding sparse memory. These memory requirements are reported differently for VkBuffer objects and VkImage objects.

Buffer and Fully-Resident Images

Buffers (both fully and partially resident) and fully-resident images can be bound to memory using only the data from VkMemoryRequirements. For all sparse resources the VkMemoryRequirements::alignment member specifies both the bindable sparse block size in bytes and required alignment of VkDeviceMemory.

Partially Resident Images

Partially resident images have a different method for binding memory. As with buffers and fully resident images, the VkMemoryRequirements::alignment field specifies the bindable sparse block size in bytes for the image.

Requesting sparse memory requirements for VkImage objects using vkGetImageSparseMemoryRequirements will return an array of one or more VkSparseImageMemoryRequirements structures. Each structure describes the sparse memory requirements for a group of aspects of the image.

The sparse image must have been created using the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag to retrieve valid sparse image memory requirements.

Sparse Image Memory Requirements

The VkSparseImageMemoryRequirements structure is defined as:

typedef struct VkSparseImageMemoryRequirements {
    VkSparseImageFormatProperties    formatProperties;
    uint32_t                         imageMipTailFirstLod;
    VkDeviceSize                     imageMipTailSize;
    VkDeviceSize                     imageMipTailOffset;
    VkDeviceSize                     imageMipTailStride;
} VkSparseImageMemoryRequirements;

formatProperties.aspectMask is the set of aspects of the image that this sparse memory requirement applies to. This will usually have a single aspect specified. However, depth/stencil images may have depth and stencil data interleaved in the same sparse block, in which case both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT would be present.
formatProperties.imageGranularity describes the dimensions of a single bindable sparse image block in texel units. For aspect VK_IMAGE_ASPECT_METADATA_BIT, all dimensions will be zero. All metadata is located in the mip tail region.
formatProperties.flags is a bitmask of VkSparseImageFormatFlagBits:
- If VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT is set the image uses a single mip tail region for all array layers.
- If VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT is set the dimensions of mip levels must be integer multiples of the corresponding dimensions of the sparse image block for levels not located in the mip tail.
- If VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT is set the image uses non-standard sparse image block dimensions. The formatProperties.imageGranularity values do not match the standard sparse image block dimension corresponding to the image’s format.
imageMipTailFirstLod is the first mip level at which image subresources are included in the mip tail region.
imageMipTailSize is the memory size (in bytes) of the mip tail region. If formatProperties.flags contains VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT, this is the size of the whole mip tail, otherwise this is the size of the mip tail of a single array layer. This value is guaranteed to be a multiple of the sparse block size in bytes.
imageMipTailOffset is the opaque memory offset used with VkSparseImageOpaqueMemoryBindInfo to bind the mip tail region(s).
imageMipTailStride is the offset stride between each array-layer’s mip tail, if formatProperties.flags does not contain VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT (otherwise the value is undefined).

To query sparse memory requirements for an image, call:

void vkGetImageSparseMemoryRequirements(
    VkDevice                                    device,
    VkImage                                     image,
    uint32_t*                                   pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);

device is the logical device that owns the image.
image is the VkImage object to get the memory requirements for.
pSparseMemoryRequirementCount is a pointer to an integer related to the number of sparse memory requirements available or queried, as described below.
pSparseMemoryRequirements is either NULL or a pointer to an array of VkSparseImageMemoryRequirements structures.

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 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 VK_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 implementation requires unused padding in the address range describing the resource.

Valid Usage (Implicit)

VUID-vkGetImageSparseMemoryRequirements-device-parameter
device must be a valid VkDevice handle
VUID-vkGetImageSparseMemoryRequirements-image-parameter
image must be a valid VkImage handle
VUID-vkGetImageSparseMemoryRequirements-pSparseMemoryRequirementCount-parameter
pSparseMemoryRequirementCount must be a valid pointer to a uint32_t value
VUID-vkGetImageSparseMemoryRequirements-pSparseMemoryRequirements-parameter
If the value referenced by pSparseMemoryRequirementCount is not 0, and pSparseMemoryRequirements is not NULL, pSparseMemoryRequirements must be a valid pointer to an array of pSparseMemoryRequirementCount VkSparseImageMemoryRequirements structures
VUID-vkGetImageSparseMemoryRequirements-image-parent
image must have been created, allocated, or retrieved from device

To query sparse memory requirements for an image, call:

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

or the equivalent command

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

device is the logical device that owns the image.
pInfo is a pointer to a VkImageSparseMemoryRequirementsInfo2 structure containing parameters required for the memory requirements query.
pSparseMemoryRequirementCount is a pointer to an integer related to the number of sparse memory requirements available or queried, as described below.
pSparseMemoryRequirements is either NULL or a pointer to an array of VkSparseImageMemoryRequirements2 structures.

Valid Usage (Implicit)

VUID-vkGetImageSparseMemoryRequirements2-device-parameter
device must be a valid VkDevice handle
VUID-vkGetImageSparseMemoryRequirements2-pInfo-parameter
pInfo must be a valid pointer to a valid VkImageSparseMemoryRequirementsInfo2 structure
VUID-vkGetImageSparseMemoryRequirements2-pSparseMemoryRequirementCount-parameter
pSparseMemoryRequirementCount must be a valid pointer to a uint32_t value
VUID-vkGetImageSparseMemoryRequirements2-pSparseMemoryRequirements-parameter
If the value referenced by pSparseMemoryRequirementCount is not 0, and pSparseMemoryRequirements is not NULL, pSparseMemoryRequirements must be a valid pointer to an array of pSparseMemoryRequirementCount VkSparseImageMemoryRequirements2 structures

The VkImageSparseMemoryRequirementsInfo2 structure is defined as:

typedef struct VkImageSparseMemoryRequirementsInfo2 {
    VkStructureType    sType;
    const void*        pNext;
    VkImage            image;
} VkImageSparseMemoryRequirementsInfo2;

or the equivalent

typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
image is the image to query.

Valid Usage (Implicit)

VUID-VkImageSparseMemoryRequirementsInfo2-sType-sType
sType must be VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2
VUID-VkImageSparseMemoryRequirementsInfo2-pNext-pNext
pNext must be NULL
VUID-VkImageSparseMemoryRequirementsInfo2-image-parameter
image must be a valid VkImage handle

The VkSparseImageMemoryRequirements2 structure is defined as:

typedef struct VkSparseImageMemoryRequirements2 {
    VkStructureType                    sType;
    void*                              pNext;
    VkSparseImageMemoryRequirements    memoryRequirements;
} VkSparseImageMemoryRequirements2;

or the equivalent

typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
memoryRequirements is a VkSparseImageMemoryRequirements structure describing the memory requirements of the sparse image.

Valid Usage (Implicit)

VUID-VkSparseImageMemoryRequirements2-sType-sType
sType must be VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2
VUID-VkSparseImageMemoryRequirements2-pNext-pNext
pNext must be NULL

31.7.6. Binding Resource Memory

Non-sparse resources are backed by a single physical allocation prior to device use (via vkBindImageMemory or vkBindBufferMemory), and their backing must not be changed. On the other hand, sparse resources can be bound to memory non-contiguously and these bindings can be altered during the lifetime of the resource.

Note

It is important to note that freeing a VkDeviceMemory object with vkFreeMemory will not cause resources (or resource regions) bound to the memory object to become unbound. Applications must not access resources bound to memory that has been freed.

Sparse memory bindings execute on a queue that includes the VK_QUEUE_SPARSE_BINDING_BIT bit. Applications must use synchronization primitives to guarantee that other queues do not access ranges of memory concurrently with a binding change. Applications can access other ranges of the same resource while a bind operation is executing.

Note

Implementations must provide a guarantee that simultaneously binding sparse blocks while another queue accesses those same sparse blocks via a sparse resource must not access memory owned by another process or otherwise corrupt the system.

While some implementations may include VK_QUEUE_SPARSE_BINDING_BIT support in queue families that also include graphics and compute support, other implementations may only expose a VK_QUEUE_SPARSE_BINDING_BIT-only queue family. In either case, applications must use synchronization primitives to explicitly request any ordering dependencies between sparse memory binding operations and other graphics/compute/transfer operations, as sparse binding operations are not automatically ordered against command buffer execution, even within a single queue.

When binding memory explicitly for the VK_IMAGE_ASPECT_METADATA_BIT the application must use the VK_SPARSE_MEMORY_BIND_METADATA_BIT in the VkSparseMemoryBind::flags field when binding memory. Binding memory for metadata is done the same way as binding memory for the mip tail, with the addition of the VK_SPARSE_MEMORY_BIND_METADATA_BIT flag.

Binding the mip tail for any aspect must only be performed using VkSparseImageOpaqueMemoryBindInfo. If formatProperties.flags contains VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT, then it can be bound with a single VkSparseMemoryBind structure, with resourceOffset = imageMipTailOffset and size = imageMipTailSize.

If formatProperties.flags does not contain VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT then the offset for the mip tail in each array layer is given as:

arrayMipTailOffset = imageMipTailOffset + arrayLayer * imageMipTailStride;

and the mip tail can be bound with layerCount VkSparseMemoryBind structures, each using size = imageMipTailSize and resourceOffset = arrayMipTailOffset as defined above.

Sparse memory binding is handled by the following APIs and related data structures.

Sparse Memory Binding Functions

The VkSparseMemoryBind structure is defined as:

typedef struct VkSparseMemoryBind {
    VkDeviceSize               resourceOffset;
    VkDeviceSize               size;
    VkDeviceMemory             memory;
    VkDeviceSize               memoryOffset;
    VkSparseMemoryBindFlags    flags;
} VkSparseMemoryBind;

resourceOffset is the offset into the resource.
size is the size of the memory region to be bound.
memory is the VkDeviceMemory object that the range of the resource is bound to. If memory is VK_NULL_HANDLE, the range is unbound.
memoryOffset is the offset into the VkDeviceMemory object to bind the resource range to. If memory is VK_NULL_HANDLE, this value is ignored.
flags is a bitmask of VkSparseMemoryBindFlagBits specifying usage of the binding operation.

The binding range [resourceOffset, resourceOffset + size) has different constraints based on flags. If flags contains VK_SPARSE_MEMORY_BIND_METADATA_BIT, the binding range must be within the mip tail region of the metadata aspect. This metadata region is defined by:

: metadataRegion = [base, base + imageMipTailSize)
: base = imageMipTailOffset + imageMipTailStride × n

and imageMipTailOffset, imageMipTailSize, and imageMipTailStride values are from the VkSparseImageMemoryRequirements corresponding to the metadata aspect of the image, and n is a valid array layer index for the image,

imageMipTailStride is considered to be zero for aspects where VkSparseImageMemoryRequirements::formatProperties.flags contains VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT.

If flags does not contain VK_SPARSE_MEMORY_BIND_METADATA_BIT, the binding range must be within the range [0,VkMemoryRequirements::size).

Valid Usage

VUID-VkSparseMemoryBind-memory-01096
If memory is not VK_NULL_HANDLE, memory and memoryOffset must match the memory requirements of the resource, as described in section Resource Memory Association
VUID-VkSparseMemoryBind-memory-01097
If memory is not VK_NULL_HANDLE, memory must not have been created with a memory type that reports VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT bit set
VUID-VkSparseMemoryBind-size-01098
size must be greater than 0
VUID-VkSparseMemoryBind-resourceOffset-01099
resourceOffset must be less than the size of the resource
VUID-VkSparseMemoryBind-size-01100
size must be less than or equal to the size of the resource minus resourceOffset
VUID-VkSparseMemoryBind-memoryOffset-01101
memoryOffset must be less than the size of memory
VUID-VkSparseMemoryBind-size-01102
size must be less than or equal to the size of memory minus memoryOffset
VUID-VkSparseMemoryBind-memory-02730
If memory was created with VkExportMemoryAllocateInfo::handleTypes not equal to 0, at least one handle type it contained must also have been set in VkExternalMemoryBufferCreateInfo::handleTypes or VkExternalMemoryImageCreateInfo::handleTypes when the resource was created.
VUID-VkSparseMemoryBind-memory-02731
If memory was created by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryBufferCreateInfo::handleTypes or VkExternalMemoryImageCreateInfo::handleTypes when the resource was created.

Valid Usage (Implicit)

VUID-VkSparseMemoryBind-memory-parameter
If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle
VUID-VkSparseMemoryBind-flags-parameter
flags must be a valid combination of VkSparseMemoryBindFlagBits values

Bits which can be set in VkSparseMemoryBind::flags, specifying usage of a sparse memory binding operation, are:

typedef enum VkSparseMemoryBindFlagBits {
    VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
    VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkSparseMemoryBindFlagBits;

VK_SPARSE_MEMORY_BIND_METADATA_BIT specifies that the memory being bound is only for the metadata aspect.

typedef VkFlags VkSparseMemoryBindFlags;

VkSparseMemoryBindFlags is a bitmask type for setting a mask of zero or more VkSparseMemoryBindFlagBits.

Memory is bound to VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_BINDING_BIT flag using the following structure:

typedef struct VkSparseBufferMemoryBindInfo {
    VkBuffer                     buffer;
    uint32_t                     bindCount;
    const VkSparseMemoryBind*    pBinds;
} VkSparseBufferMemoryBindInfo;

buffer is the VkBuffer object to be bound.
bindCount is the number of VkSparseMemoryBind structures in the pBinds array.
pBinds is a pointer to array of VkSparseMemoryBind structures.

Valid Usage (Implicit)

VUID-VkSparseBufferMemoryBindInfo-buffer-parameter
buffer must be a valid VkBuffer handle
VUID-VkSparseBufferMemoryBindInfo-pBinds-parameter
pBinds must be a valid pointer to an array of bindCount valid VkSparseMemoryBind structures
VUID-VkSparseBufferMemoryBindInfo-bindCount-arraylength
bindCount must be greater than 0

Memory is bound to opaque regions of VkImage objects created with the VK_IMAGE_CREATE_SPARSE_BINDING_BIT flag using the following structure:

typedef struct VkSparseImageOpaqueMemoryBindInfo {
    VkImage                      image;
    uint32_t                     bindCount;
    const VkSparseMemoryBind*    pBinds;
} VkSparseImageOpaqueMemoryBindInfo;

image is the VkImage object to be bound.
bindCount is the number of VkSparseMemoryBind structures in the pBinds array.
pBinds is a pointer to an array of VkSparseMemoryBind structures.

Valid Usage

VUID-VkSparseImageOpaqueMemoryBindInfo-pBinds-01103
If the flags member of any element of pBinds contains VK_SPARSE_MEMORY_BIND_METADATA_BIT, the binding range defined must be within the mip tail region of the metadata aspect of image

Valid Usage (Implicit)

VUID-VkSparseImageOpaqueMemoryBindInfo-image-parameter
image must be a valid VkImage handle
VUID-VkSparseImageOpaqueMemoryBindInfo-pBinds-parameter
pBinds must be a valid pointer to an array of bindCount valid VkSparseMemoryBind structures
VUID-VkSparseImageOpaqueMemoryBindInfo-bindCount-arraylength
bindCount must be greater than 0

Note

This operation is normally used to bind memory to fully-resident sparse images or for mip tail regions of partially resident images. However, it can also be used to bind memory for the entire binding range of partially resident images.

In case flags does not contain VK_SPARSE_MEMORY_BIND_METADATA_BIT, the resourceOffset is in the range [0, VkMemoryRequirements::size), This range includes data from all aspects of the image, including metadata. For most implementations this will probably mean that the resourceOffset is a simple device address offset within the resource. It is possible for an application to bind a range of memory that includes both resource data and metadata. However, the application would not know what part of the image the memory is used for, or if any range is being used for metadata.

When flags contains VK_SPARSE_MEMORY_BIND_METADATA_BIT, the binding range specified must be within the mip tail region of the metadata aspect. In this case the resourceOffset is not required to be a simple device address offset within the resource. However, it is defined to be within [imageMipTailOffset, imageMipTailOffset + imageMipTailSize) for the metadata aspect. See VkSparseMemoryBind for the full constraints on binding region with this flag present.

editing-note

(Jon) The preceding NOTE refers to flags, which is presumably a reference to VkSparseMemoryBind above, even though that is not contextually clear.

Memory can be bound to sparse image blocks of VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag using the following structure:

typedef struct VkSparseImageMemoryBindInfo {
    VkImage                           image;
    uint32_t                          bindCount;
    const VkSparseImageMemoryBind*    pBinds;
} VkSparseImageMemoryBindInfo;

image is the VkImage object to be bound
bindCount is the number of VkSparseImageMemoryBind structures in pBinds array
pBinds is a pointer to an array of VkSparseImageMemoryBind structures

Valid Usage

VUID-VkSparseImageMemoryBindInfo-subresource-01722
The subresource.mipLevel member of each element of pBinds must be less than the mipLevels specified in VkImageCreateInfo when image was created
VUID-VkSparseImageMemoryBindInfo-subresource-01723
The subresource.arrayLayer member of each element of pBinds must be less than the arrayLayers specified in VkImageCreateInfo when image was created

Valid Usage (Implicit)

VUID-VkSparseImageMemoryBindInfo-image-parameter
image must be a valid VkImage handle
VUID-VkSparseImageMemoryBindInfo-pBinds-parameter
pBinds must be a valid pointer to an array of bindCount valid VkSparseImageMemoryBind structures
VUID-VkSparseImageMemoryBindInfo-bindCount-arraylength
bindCount must be greater than 0

The VkSparseImageMemoryBind structure is defined as:

typedef struct VkSparseImageMemoryBind {
    VkImageSubresource         subresource;
    VkOffset3D                 offset;
    VkExtent3D                 extent;
    VkDeviceMemory             memory;
    VkDeviceSize               memoryOffset;
    VkSparseMemoryBindFlags    flags;
} VkSparseImageMemoryBind;

subresource is the image aspect and region of interest in the image.
offset are the coordinates of the first texel within the image subresource to bind.
extent is the size in texels of the region within the image subresource to bind. The extent must be a multiple of the sparse image block dimensions, except when binding sparse image blocks along the edge of an image subresource it can instead be such that any coordinate of offset + extent equals the corresponding dimensions of the image subresource.
memory is the VkDeviceMemory object that the sparse image blocks of the image are bound to. If memory is VK_NULL_HANDLE, the sparse image blocks are unbound.
memoryOffset is an offset into VkDeviceMemory object. If memory is VK_NULL_HANDLE, this value is ignored.
flags are sparse memory binding flags.

Valid Usage

VUID-VkSparseImageMemoryBind-memory-01104
If the sparse aliased residency feature is not enabled, and if any other resources are bound to ranges of memory, the range of memory being bound must not overlap with those bound ranges
VUID-VkSparseImageMemoryBind-memory-01105
memory and memoryOffset must match the memory requirements of the calling command’s image, as described in section Resource Memory Association
VUID-VkSparseImageMemoryBind-subresource-01106
subresource must be a valid image subresource for image (see Image Views)
VUID-VkSparseImageMemoryBind-offset-01107
offset.x must be a multiple of the sparse image block width (VkSparseImageFormatProperties::imageGranularity.width) of the image
VUID-VkSparseImageMemoryBind-extent-01108
extent.width must either be a multiple of the sparse image block width of the image, or else (extent.width + offset.x) must equal the width of the image subresource
VUID-VkSparseImageMemoryBind-offset-01109
offset.y must be a multiple of the sparse image block height (VkSparseImageFormatProperties::imageGranularity.height) of the image
VUID-VkSparseImageMemoryBind-extent-01110
extent.height must either be a multiple of the sparse image block height of the image, or else (extent.height + offset.y) must equal the height of the image subresource
VUID-VkSparseImageMemoryBind-offset-01111
offset.z must be a multiple of the sparse image block depth (VkSparseImageFormatProperties::imageGranularity.depth) of the image
VUID-VkSparseImageMemoryBind-extent-01112
extent.depth must either be a multiple of the sparse image block depth of the image, or else (extent.depth + offset.z) must equal the depth of the image subresource
VUID-VkSparseImageMemoryBind-memory-02732
If memory was created with VkExportMemoryAllocateInfo::handleTypes not equal to 0, at least one handle type it contained must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when the image was created.
VUID-VkSparseImageMemoryBind-memory-02733
If memory was created by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when image was created.

Valid Usage (Implicit)

VUID-VkSparseImageMemoryBind-subresource-parameter
subresource must be a valid VkImageSubresource structure
VUID-VkSparseImageMemoryBind-memory-parameter
If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle
VUID-VkSparseImageMemoryBind-flags-parameter
flags must be a valid combination of VkSparseMemoryBindFlagBits values

To submit sparse binding operations to a queue, call:

VkResult vkQueueBindSparse(
    VkQueue                                     queue,
    uint32_t                                    bindInfoCount,
    const VkBindSparseInfo*                     pBindInfo,
    VkFence                                     fence);

queue is the queue that the sparse binding operations will be submitted to.
bindInfoCount is the number of elements in the pBindInfo array.
pBindInfo is a pointer to an array of VkBindSparseInfo structures, each specifying a sparse binding submission batch.
fence is an optional handle to a fence to be signaled. If fence is not VK_NULL_HANDLE, it defines a fence signal operation.

vkQueueBindSparse is a queue submission command, with each batch defined by an element of pBindInfo as a VkBindSparseInfo structure. Batches begin execution in the order they appear in pBindInfo, but may complete out of order.

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.

As no operation to vkQueueBindSparse causes any pipeline stage to access memory, synchronization primitives used in this command effectively only define execution dependencies.

Additional information about fence and semaphore operation is described in the synchronization chapter.

Valid Usage

VUID-vkQueueBindSparse-fence-01113
If fence is not VK_NULL_HANDLE, fence must be unsignaled
VUID-vkQueueBindSparse-fence-01114
If fence is not VK_NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue
VUID-vkQueueBindSparse-pSignalSemaphores-01115
Each element of the pSignalSemaphores member of each element of pBindInfo must be unsignaled when the semaphore signal operation it defines is executed on the device
VUID-vkQueueBindSparse-pWaitSemaphores-01116
When a semaphore wait operation referring to a binary semaphore defined by any element of the pWaitSemaphores member of any element of pBindInfo executes on queue, there must be no other queues waiting on the same semaphore.
VUID-vkQueueBindSparse-pWaitSemaphores-01117
All elements of the pWaitSemaphores member of all elements of pBindInfo member referring to a binary semaphore must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution.
VUID-vkQueueBindSparse-pWaitSemaphores-03245
All elements of the pWaitSemaphores member of all elements of pBindInfo created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY must reference a semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) must have also been submitted for execution.

Valid Usage (Implicit)

VUID-vkQueueBindSparse-queue-parameter
queue must be a valid VkQueue handle
VUID-vkQueueBindSparse-pBindInfo-parameter
If bindInfoCount is not 0, pBindInfo must be a valid pointer to an array of bindInfoCount valid VkBindSparseInfo structures
VUID-vkQueueBindSparse-fence-parameter
If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle
VUID-vkQueueBindSparse-queuetype
The queue must support sparse binding operations
VUID-vkQueueBindSparse-commonparent
Both of fence, and queue that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to queue 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

Command Properties

SPARSE_BINDING

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST

The VkBindSparseInfo structure is defined as:

typedef struct VkBindSparseInfo {
    VkStructureType                             sType;
    const void*                                 pNext;
    uint32_t                                    waitSemaphoreCount;
    const VkSemaphore*                          pWaitSemaphores;
    uint32_t                                    bufferBindCount;
    const VkSparseBufferMemoryBindInfo*         pBufferBinds;
    uint32_t                                    imageOpaqueBindCount;
    const VkSparseImageOpaqueMemoryBindInfo*    pImageOpaqueBinds;
    uint32_t                                    imageBindCount;
    const VkSparseImageMemoryBindInfo*          pImageBinds;
    uint32_t                                    signalSemaphoreCount;
    const VkSemaphore*                          pSignalSemaphores;
} VkBindSparseInfo;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
waitSemaphoreCount is the number of semaphores upon which to wait before executing the sparse binding operations for the batch.
pWaitSemaphores is a pointer to an array of semaphores upon which to wait on before the sparse binding operations for this batch begin execution. If semaphores to wait on are provided, they define a semaphore wait operation.
bufferBindCount is the number of sparse buffer bindings to perform in the batch.
pBufferBinds is a pointer to an array of VkSparseBufferMemoryBindInfo structures.
imageOpaqueBindCount is the number of opaque sparse image bindings to perform.
pImageOpaqueBinds is a pointer to an array of VkSparseImageOpaqueMemoryBindInfo structures, indicating opaque sparse image bindings to perform.
imageBindCount is the number of sparse image bindings to perform.
pImageBinds is a pointer to an array of VkSparseImageMemoryBindInfo structures, indicating sparse image bindings to perform.
signalSemaphoreCount is the number of semaphores to be signaled once the sparse binding operations specified by the structure have completed execution.
pSignalSemaphores is a pointer to an array of semaphores which will be signaled when the sparse binding operations for this batch have completed execution. If semaphores to be signaled are provided, they define a semaphore signal operation.

Valid Usage

VUID-VkBindSparseInfo-pWaitSemaphores-03246
If any element of pWaitSemaphores or pSignalSemaphores was created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE then the pNext chain must include a VkTimelineSemaphoreSubmitInfo structure
VUID-VkBindSparseInfo-pNext-03247
If the pNext chain of this structure includes a VkTimelineSemaphoreSubmitInfo structure and any element of pWaitSemaphores was created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE then its waitSemaphoreValueCount member must equal waitSemaphoreCount
VUID-VkBindSparseInfo-pNext-03248
If the pNext chain of this structure includes a VkTimelineSemaphoreSubmitInfo structure and any element of pSignalSemaphores was created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE then its signalSemaphoreValueCount member must equal signalSemaphoreCount
VUID-VkBindSparseInfo-pSignalSemaphores-03249
For each element of pSignalSemaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE the corresponding element of VkTimelineSemaphoreSubmitInfo::pSignalSemaphoreValues must have a value greater than the current value of the semaphore when the semaphore signal operation is executed
VUID-VkBindSparseInfo-pWaitSemaphores-03250
For each element of pWaitSemaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE the corresponding element of VkTimelineSemaphoreSubmitInfo::pWaitSemaphoreValues must have a value which does not differ from the current value of the semaphore or from the value of any outstanding semaphore wait or signal operation on that semaphore by more than maxTimelineSemaphoreValueDifference.
VUID-VkBindSparseInfo-pSignalSemaphores-03251
For each element of pSignalSemaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE the corresponding element of VkTimelineSemaphoreSubmitInfo::pSignalSemaphoreValues must have a value which does not differ from the current value of the semaphore or from the value of any outstanding semaphore wait or signal operation on that semaphore by more than maxTimelineSemaphoreValueDifference.

Valid Usage (Implicit)

VUID-VkBindSparseInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_BIND_SPARSE_INFO
VUID-VkBindSparseInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupBindSparseInfo or VkTimelineSemaphoreSubmitInfo
VUID-VkBindSparseInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkBindSparseInfo-pWaitSemaphores-parameter
If waitSemaphoreCount is not 0, pWaitSemaphores must be a valid pointer to an array of waitSemaphoreCount valid VkSemaphore handles
VUID-VkBindSparseInfo-pBufferBinds-parameter
If bufferBindCount is not 0, pBufferBinds must be a valid pointer to an array of bufferBindCount valid VkSparseBufferMemoryBindInfo structures
VUID-VkBindSparseInfo-pImageOpaqueBinds-parameter
If imageOpaqueBindCount is not 0, pImageOpaqueBinds must be a valid pointer to an array of imageOpaqueBindCount valid VkSparseImageOpaqueMemoryBindInfo structures
VUID-VkBindSparseInfo-pImageBinds-parameter
If imageBindCount is not 0, pImageBinds must be a valid pointer to an array of imageBindCount valid VkSparseImageMemoryBindInfo structures
VUID-VkBindSparseInfo-pSignalSemaphores-parameter
If signalSemaphoreCount is not 0, pSignalSemaphores must be a valid pointer to an array of signalSemaphoreCount valid VkSemaphore handles
VUID-VkBindSparseInfo-commonparent
Both of the elements of pSignalSemaphores, and the elements of pWaitSemaphores that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

If the pNext chain of VkBindSparseInfo includes a VkDeviceGroupBindSparseInfo structure, then that structure includes device indices specifying which instance of the resources and memory are bound.

The VkDeviceGroupBindSparseInfo structure is defined as:

typedef struct VkDeviceGroupBindSparseInfo {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           resourceDeviceIndex;
    uint32_t           memoryDeviceIndex;
} VkDeviceGroupBindSparseInfo;

or the equivalent

typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
resourceDeviceIndex is a device index indicating which instance of the resource is bound.
memoryDeviceIndex is a device index indicating which instance of the memory the resource instance is bound to.

These device indices apply to all buffer and image memory binds included in the batch pointing to this structure. The semaphore waits and signals for the batch are executed only by the physical device specified by the resourceDeviceIndex.

If this structure is not present, resourceDeviceIndex and memoryDeviceIndex are assumed to be zero.

Valid Usage

VUID-VkDeviceGroupBindSparseInfo-resourceDeviceIndex-01118
resourceDeviceIndex and memoryDeviceIndex must both be valid device indices.
VUID-VkDeviceGroupBindSparseInfo-memoryDeviceIndex-01119
Each memory allocation bound in this batch must have allocated an instance for memoryDeviceIndex.

Valid Usage (Implicit)

VUID-VkDeviceGroupBindSparseInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO

31.8. Examples

The following examples illustrate basic creation of sparse images and binding them to physical memory.

31.8.1. Basic Sparse Resources

This basic example creates a normal VkImage object but uses fine-grained memory allocation to back the resource with multiple memory ranges.

VkDevice                device;
VkQueue                 queue;
VkImage                 sparseImage;
VkAllocationCallbacks*  pAllocator = NULL;
VkMemoryRequirements    memoryRequirements = {};
VkDeviceSize            offset = 0;
VkSparseMemoryBind      binds[MAX_CHUNKS] = {}; // MAX_CHUNKS is NOT part of Vulkan
uint32_t                bindCount = 0;

// ...

// Allocate image object
const VkImageCreateInfo sparseImageInfo =
{
    VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,        // sType
    NULL,                                       // pNext
    VK_IMAGE_CREATE_SPARSE_BINDING_BIT | ...,   // flags
    ...
};
vkCreateImage(device, &sparseImageInfo, pAllocator, &sparseImage);

// Get memory requirements
vkGetImageMemoryRequirements(
    device,
    sparseImage,
    &memoryRequirements);

// Bind memory in fine-grained fashion, find available memory ranges
// from potentially multiple VkDeviceMemory pools.
// (Illustration purposes only, can be optimized for perf)
while (memoryRequirements.size && bindCount < MAX_CHUNKS)
{
    VkSparseMemoryBind* pBind = &binds[bindCount];
    pBind->resourceOffset = offset;

    AllocateOrGetMemoryRange(
        device,
        &memoryRequirements,
        &pBind->memory,
        &pBind->memoryOffset,
        &pBind->size);

    // memory ranges must be sized as multiples of the alignment
    assert(IsMultiple(pBind->size, memoryRequirements.alignment));
    assert(IsMultiple(pBind->memoryOffset, memoryRequirements.alignment));

    memoryRequirements.size -= pBind->size;
    offset                  += pBind->size;
    bindCount++;
}

// Ensure all image has backing
if (memoryRequirements.size)
{
    // Error condition - too many chunks
}

const VkSparseImageOpaqueMemoryBindInfo opaqueBindInfo =
{
    sparseImage,                                // image
    bindCount,                                  // bindCount
    binds                                       // pBinds
};

const VkBindSparseInfo bindSparseInfo =
{
    VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,         // sType
    NULL,                                       // pNext
    ...
    1,                                          // imageOpaqueBindCount
    &opaqueBindInfo,                            // pImageOpaqueBinds
    ...
};

// vkQueueBindSparse is externally synchronized per queue object.
AcquireQueueOwnership(queue);

// Actually bind memory
vkQueueBindSparse(queue, 1, &bindSparseInfo, VK_NULL_HANDLE);

ReleaseQueueOwnership(queue);

31.8.2. Advanced Sparse Resources

This more advanced example creates an arrayed color attachment / texture image and binds only LOD zero and the required metadata to physical memory.

VkDevice                            device;
VkQueue                             queue;
VkImage                             sparseImage;
VkAllocationCallbacks*              pAllocator = NULL;
VkMemoryRequirements                memoryRequirements = {};
uint32_t                            sparseRequirementsCount = 0;
VkSparseImageMemoryRequirements*    pSparseReqs = NULL;
VkSparseMemoryBind                  binds[MY_IMAGE_ARRAY_SIZE] = {};
VkSparseImageMemoryBind             imageBinds[MY_IMAGE_ARRAY_SIZE] = {};
uint32_t                            bindCount = 0;

// Allocate image object (both renderable and sampleable)
const VkImageCreateInfo sparseImageInfo =
{
    VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,        // sType
    NULL,                                       // pNext
    VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT | ..., // flags
    ...
    VK_FORMAT_R8G8B8A8_UNORM,                   // format
    ...
    MY_IMAGE_ARRAY_SIZE,                        // arrayLayers
    ...
    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
    VK_IMAGE_USAGE_SAMPLED_BIT,                 // usage
    ...
};
vkCreateImage(device, &sparseImageInfo, pAllocator, &sparseImage);

// Get memory requirements
vkGetImageMemoryRequirements(
    device,
    sparseImage,
    &memoryRequirements);

// Get sparse image aspect properties
vkGetImageSparseMemoryRequirements(
    device,
    sparseImage,
    &sparseRequirementsCount,
    NULL);

pSparseReqs = (VkSparseImageMemoryRequirements*)
    malloc(sparseRequirementsCount * sizeof(VkSparseImageMemoryRequirements));

vkGetImageSparseMemoryRequirements(
    device,
    sparseImage,
    &sparseRequirementsCount,
    pSparseReqs);

// Bind LOD level 0 and any required metadata to memory
for (uint32_t i = 0; i < sparseRequirementsCount; ++i)
{
    if (pSparseReqs[i].formatProperties.aspectMask &
        VK_IMAGE_ASPECT_METADATA_BIT)
    {
        // Metadata must not be combined with other aspects
        assert(pSparseReqs[i].formatProperties.aspectMask ==
               VK_IMAGE_ASPECT_METADATA_BIT);

        if (pSparseReqs[i].formatProperties.flags &
            VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT)
        {
            VkSparseMemoryBind* pBind = &binds[bindCount];
            pBind->memorySize = pSparseReqs[i].imageMipTailSize;
            bindCount++;

            // ... Allocate memory range

            pBind->resourceOffset = pSparseReqs[i].imageMipTailOffset;
            pBind->memoryOffset = /* allocated memoryOffset */;
            pBind->memory = /* allocated memory */;
            pBind->flags = VK_SPARSE_MEMORY_BIND_METADATA_BIT;

        }
        else
        {
            // Need a mip tail region per array layer.
            for (uint32_t a = 0; a < sparseImageInfo.arrayLayers; ++a)
            {
                VkSparseMemoryBind* pBind = &binds[bindCount];
                pBind->memorySize = pSparseReqs[i].imageMipTailSize;
                bindCount++;

                // ... Allocate memory range

                pBind->resourceOffset = pSparseReqs[i].imageMipTailOffset +
                                        (a * pSparseReqs[i].imageMipTailStride);

                pBind->memoryOffset = /* allocated memoryOffset */;
                pBind->memory = /* allocated memory */
                pBind->flags = VK_SPARSE_MEMORY_BIND_METADATA_BIT;
            }
        }
    }
    else
    {
        // resource data
        VkExtent3D lod0BlockSize =
        {
            AlignedDivide(
                sparseImageInfo.extent.width,
                pSparseReqs[i].formatProperties.imageGranularity.width);
            AlignedDivide(
                sparseImageInfo.extent.height,
                pSparseReqs[i].formatProperties.imageGranularity.height);
            AlignedDivide(
                sparseImageInfo.extent.depth,
                pSparseReqs[i].formatProperties.imageGranularity.depth);
        }
        size_t totalBlocks =
            lod0BlockSize.width *
            lod0BlockSize.height *
            lod0BlockSize.depth;

        // Each block is the same size as the alignment requirement,
        // calculate total memory size for level 0
        VkDeviceSize lod0MemSize = totalBlocks * memoryRequirements.alignment;

        // Allocate memory for each array layer
        for (uint32_t a = 0; a < sparseImageInfo.arrayLayers; ++a)
        {
            // ... Allocate memory range

            VkSparseImageMemoryBind* pBind = &imageBinds[a];
            pBind->subresource.aspectMask = pSparseReqs[i].formatProperties.aspectMask;
            pBind->subresource.mipLevel = 0;
            pBind->subresource.arrayLayer = a;

            pBind->offset = (VkOffset3D){0, 0, 0};
            pBind->extent = sparseImageInfo.extent;
            pBind->memoryOffset = /* allocated memoryOffset */;
            pBind->memory = /* allocated memory */;
            pBind->flags = 0;
        }
    }

    free(pSparseReqs);
}

const VkSparseImageOpaqueMemoryBindInfo opaqueBindInfo =
{
    sparseImage,                                // image
    bindCount,                                  // bindCount
    binds                                       // pBinds
};

const VkSparseImageMemoryBindInfo imageBindInfo =
{
    sparseImage,                                // image
    sparseImageInfo.arrayLayers,                // bindCount
    imageBinds                                  // pBinds
};

const VkBindSparseInfo bindSparseInfo =
{
    VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,         // sType
    NULL,                                       // pNext
    ...
    1,                                          // imageOpaqueBindCount
    &opaqueBindInfo,                            // pImageOpaqueBinds
    1,                                          // imageBindCount
    &imageBindInfo,                             // pImageBinds
    ...
};

// vkQueueBindSparse is externally synchronized per queue object.
AcquireQueueOwnership(queue);

// Actually bind memory
vkQueueBindSparse(queue, 1, &bindSparseInfo, VK_NULL_HANDLE);

ReleaseQueueOwnership(queue);

32. Window System Integration (WSI)

This chapter discusses the window system integration (WSI) between the Vulkan API and the various forms of displaying the results of rendering to a user. Since the Vulkan API can be used without displaying results, WSI is provided through the use of optional Vulkan extensions. This chapter provides an overview of WSI. See the appendix for additional details of each WSI extension, including which extensions must be enabled in order to use each of the functions described in this chapter.

32.1. WSI Platform

A platform is an abstraction for a window system, OS, etc. Some examples include MS Windows, Android, and Wayland. The Vulkan API may be integrated in a unique manner for each platform.

The Vulkan API does not define any type of platform object. Platform-specific WSI extensions are defined, each containing platform-specific functions for using WSI. Use of these extensions is guarded by preprocessor symbols as defined in the Window System-Specific Header Control appendix.

In order for an application to be compiled to use WSI with a given platform, it must either:

#define the appropriate preprocessor symbol prior to including the vulkan.h header file, or
include vulkan_core.h and any native platform headers, followed by the appropriate platform-specific header.

The preprocessor symbols and platform-specific headers are defined in the Window System Extensions and Headers table.

Each platform-specific extension is an instance extension. The application must enable instance extensions with vkCreateInstance before using them.

32.2. WSI Surface

Native platform surface or window objects are abstracted by surface objects, which are represented by VkSurfaceKHR handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)

The VK_KHR_surface extension declares the VkSurfaceKHR object, and provides a function for destroying VkSurfaceKHR objects. Separate platform-specific extensions each provide a function for creating a VkSurfaceKHR object for the respective platform. From the application’s perspective this is an opaque handle, just like the handles of other Vulkan objects.

Note

On certain platforms, the Vulkan loader and ICDs may have conventions that treat the handle as a pointer to a structure containing the platform-specific information about the surface. This will be described in the documentation for the loader-ICD interface, and in the vk_icd.h header file of the LoaderAndTools source-code repository. This does not affect the loader-layer interface; layers may wrap VkSurfaceKHR objects.

editing-note

TODO: Consider replacing the above note editing note with a pointer to the loader spec when it exists. However, the information is not relevant to users of the API nor does it affect conformance of a Vulkan implementation to this spec.

32.2.1. Android Platform

To create a VkSurfaceKHR object for an Android native window, call:

VkResult vkCreateAndroidSurfaceKHR(
    VkInstance                                  instance,
    const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

instance is the instance to associate the surface with.
pCreateInfo is a pointer to a VkAndroidSurfaceCreateInfoKHR structure containing parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface is a pointer to a VkSurfaceKHR handle in which the created surface object is returned.

During the lifetime of a surface created using a particular ANativeWindow handle any attempts to create another surface for the same ANativeWindow and any attempts to connect to the same ANativeWindow through other platform mechanisms will fail.

Note

In particular, only one VkSurfaceKHR can exist at a time for a given window. Similarly, a native window cannot be used by both a VkSurfaceKHR and EGLSurface simultaneously.

If successful, vkCreateAndroidSurfaceKHR increments the ANativeWindow’s reference count, and vkDestroySurfaceKHR will decrement it.

On Android, when a swapchain’s imageExtent does not match the surface’s currentExtent, the presentable images will be scaled to the surface’s dimensions during presentation. minImageExtent is (1,1), and maxImageExtent is the maximum image size supported by the consumer. For the system compositor, currentExtent is the window size (i.e. the consumer’s preferred size).

Valid Usage (Implicit)

VUID-vkCreateAndroidSurfaceKHR-instance-parameter
instance must be a valid VkInstance handle
VUID-vkCreateAndroidSurfaceKHR-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkAndroidSurfaceCreateInfoKHR structure
VUID-vkCreateAndroidSurfaceKHR-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateAndroidSurfaceKHR-pSurface-parameter
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR

The VkAndroidSurfaceCreateInfoKHR structure is defined as:

typedef struct VkAndroidSurfaceCreateInfoKHR {
    VkStructureType                   sType;
    const void*                       pNext;
    VkAndroidSurfaceCreateFlagsKHR    flags;
    struct ANativeWindow*             window;
} VkAndroidSurfaceCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
window is a pointer to the ANativeWindow to associate the surface with.

Valid Usage

VUID-VkAndroidSurfaceCreateInfoKHR-window-01248
window must point to a valid Android ANativeWindow.

Valid Usage (Implicit)

VUID-VkAndroidSurfaceCreateInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR
VUID-VkAndroidSurfaceCreateInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkAndroidSurfaceCreateInfoKHR-flags-zerobitmask
flags must be 0

To remove an unnecessary compile-time dependency, an incomplete type definition of ANativeWindow is provided in the Vulkan headers:

struct ANativeWindow;

The actual ANativeWindow type is defined in Android NDK headers.

32.2.2. Wayland Platform

To create a VkSurfaceKHR object for a Wayland surface, call:

VkResult vkCreateWaylandSurfaceKHR(
    VkInstance                                  instance,
    const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

instance is the instance to associate the surface with.
pCreateInfo is a pointer to a VkWaylandSurfaceCreateInfoKHR structure containing parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface is a pointer to a VkSurfaceKHR handle in which the created surface object is returned.

Valid Usage (Implicit)

VUID-vkCreateWaylandSurfaceKHR-instance-parameter
instance must be a valid VkInstance handle
VUID-vkCreateWaylandSurfaceKHR-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkWaylandSurfaceCreateInfoKHR structure
VUID-vkCreateWaylandSurfaceKHR-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateWaylandSurfaceKHR-pSurface-parameter
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkWaylandSurfaceCreateInfoKHR structure is defined as:

typedef struct VkWaylandSurfaceCreateInfoKHR {
    VkStructureType                   sType;
    const void*                       pNext;
    VkWaylandSurfaceCreateFlagsKHR    flags;
    struct wl_display*                display;
    struct wl_surface*                surface;
} VkWaylandSurfaceCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
display and surface are pointers to the Wayland wl_display and wl_surface to associate the surface with.

Valid Usage

VUID-VkWaylandSurfaceCreateInfoKHR-display-01304
display must point to a valid Wayland wl_display.
VUID-VkWaylandSurfaceCreateInfoKHR-surface-01305
surface must point to a valid Wayland wl_surface.

Valid Usage (Implicit)

VUID-VkWaylandSurfaceCreateInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR
VUID-VkWaylandSurfaceCreateInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkWaylandSurfaceCreateInfoKHR-flags-zerobitmask
flags must be 0

On Wayland, currentExtent is the special value (0xFFFFFFFF, 0xFFFFFFFF), indicating that the surface size will be determined by the extent of a swapchain targeting the surface. Whatever the application sets a swapchain’s imageExtent to will be the size of the window, after the first image is presented. minImageExtent is (1,1), and maxImageExtent is the maximum supported surface size. Any calls to vkGetPhysicalDeviceSurfacePresentModesKHR on a surface created with vkCreateWaylandSurfaceKHR are required to return VK_PRESENT_MODE_MAILBOX_KHR as one of the valid present modes.

Some Vulkan functions may send protocol over the specified wl_display connection when using a swapchain or presentable images created from a VkSurfaceKHR referring to a wl_surface. Applications must therefore ensure that both the wl_display and the wl_surface remain valid for the lifetime of any VkSwapchainKHR objects created from a particular wl_display and wl_surface. Also, calling vkQueuePresentKHR will result in Vulkan sending wl_surface.commit requests to the underlying wl_surface of each VkSwapchainKHR objects referenced by pPresentInfo. If the swapchain is created with a present mode of VK_PRESENT_MODE_MAILBOX_KHR or VK_PRESENT_MODE_IMMEDIATE_KHR, then the corresponding wl_surface.attach, wl_surface.damage, and wl_surface.commit request must be issued by the implementation during the call to vkQueuePresentKHR and must not be issued by the implementation outside of vkQueuePresentKHR. This ensures that any Wayland requests sent by the client after the call to vkQueuePresentKHR returns will be received by the compositor after the wl_surface.commit. Regardless of the mode of swapchain creation, a new wl_event_queue must be created for each successful vkCreateWaylandSurfaceKHR call, and every Wayland object created by the implementation must be assigned to this event queue. If the platform provides Wayland 1.11 or greater, this must be implemented by the use of Wayland proxy object wrappers, to avoid race conditions.

If the application wishes to synchronize any window changes with a particular frame, such requests must be sent to the Wayland display server prior to calling vkQueuePresentKHR. For full control over interactions between Vulkan rendering and other Wayland protocol requests and events, a present mode of VK_PRESENT_MODE_MAILBOX_KHR should be used.

32.2.3. Win32 Platform

To create a VkSurfaceKHR object for a Win32 window, call:

VkResult vkCreateWin32SurfaceKHR(
    VkInstance                                  instance,
    const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

instance is the instance to associate the surface with.
pCreateInfo is a pointer to a VkWin32SurfaceCreateInfoKHR structure containing parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface is a pointer to a VkSurfaceKHR handle in which the created surface object is returned.

Valid Usage (Implicit)

VUID-vkCreateWin32SurfaceKHR-instance-parameter
instance must be a valid VkInstance handle
VUID-vkCreateWin32SurfaceKHR-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkWin32SurfaceCreateInfoKHR structure
VUID-vkCreateWin32SurfaceKHR-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateWin32SurfaceKHR-pSurface-parameter
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkWin32SurfaceCreateInfoKHR structure is defined as:

typedef struct VkWin32SurfaceCreateInfoKHR {
    VkStructureType                 sType;
    const void*                     pNext;
    VkWin32SurfaceCreateFlagsKHR    flags;
    HINSTANCE                       hinstance;
    HWND                            hwnd;
} VkWin32SurfaceCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
hinstance is the Win32 HINSTANCE for the window to associate the surface with.
hwnd is the Win32 HWND for the window to associate the surface with.

Valid Usage

VUID-VkWin32SurfaceCreateInfoKHR-hinstance-01307
hinstance must be a valid Win32 HINSTANCE.
VUID-VkWin32SurfaceCreateInfoKHR-hwnd-01308
hwnd must be a valid Win32 HWND.

Valid Usage (Implicit)

VUID-VkWin32SurfaceCreateInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR
VUID-VkWin32SurfaceCreateInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkWin32SurfaceCreateInfoKHR-flags-zerobitmask
flags must be 0

With Win32, minImageExtent, maxImageExtent, and currentExtent must always equal the window size.

The currentExtent of a Win32 surface must have both width and height greater than 0, or both of them 0.

Note

Due to above restrictions, it is only possible to create a new swapchain on this platform with imageExtent being equal to the current size of the window.

The window size may become (0, 0) on this platform (e.g. when the window is minimized), and so a swapchain cannot be created until the size changes.

typedef VkFlags VkWin32SurfaceCreateFlagsKHR;

VkWin32SurfaceCreateFlagsKHR is a bitmask type for setting a mask, but is currently reserved for future use.

32.2.4. XCB Platform

To create a VkSurfaceKHR object for an X11 window, using the XCB client-side library, call:

VkResult vkCreateXcbSurfaceKHR(
    VkInstance                                  instance,
    const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

instance is the instance to associate the surface with.
pCreateInfo is a pointer to a VkXcbSurfaceCreateInfoKHR structure containing parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface is a pointer to a VkSurfaceKHR handle in which the created surface object is returned.

Valid Usage (Implicit)

VUID-vkCreateXcbSurfaceKHR-instance-parameter
instance must be a valid VkInstance handle
VUID-vkCreateXcbSurfaceKHR-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkXcbSurfaceCreateInfoKHR structure
VUID-vkCreateXcbSurfaceKHR-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateXcbSurfaceKHR-pSurface-parameter
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkXcbSurfaceCreateInfoKHR structure is defined as:

typedef struct VkXcbSurfaceCreateInfoKHR {
    VkStructureType               sType;
    const void*                   pNext;
    VkXcbSurfaceCreateFlagsKHR    flags;
    xcb_connection_t*             connection;
    xcb_window_t                  window;
} VkXcbSurfaceCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
connection is a pointer to an xcb_connection_t to the X server.
window is the xcb_window_t for the X11 window to associate the surface with.

Valid Usage

VUID-VkXcbSurfaceCreateInfoKHR-connection-01310
connection must point to a valid X11 xcb_connection_t.
VUID-VkXcbSurfaceCreateInfoKHR-window-01311
window must be a valid X11 xcb_window_t.

Valid Usage (Implicit)

VUID-VkXcbSurfaceCreateInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR
VUID-VkXcbSurfaceCreateInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkXcbSurfaceCreateInfoKHR-flags-zerobitmask
flags must be 0

With Xcb, minImageExtent, maxImageExtent, and currentExtent must always equal the window size.

The currentExtent of an Xcb surface must have both width and height greater than 0, or both of them 0.

Note

Due to above restrictions, it is only possible to create a new swapchain on this platform with imageExtent being equal to the current size of the window.

The window size may become (0, 0) on this platform (e.g. when the window is minimized), and so a swapchain cannot be created until the size changes.

Some Vulkan functions may send protocol over the specified xcb connection when using a swapchain or presentable images created from a VkSurfaceKHR referring to an xcb window. Applications must therefore ensure the xcb connection is available to Vulkan for the duration of any functions that manipulate such swapchains or their presentable images, and any functions that build or queue command buffers that operate on such presentable images. Specifically, applications using Vulkan with xcb-based swapchains must

Avoid holding a server grab on an xcb connection while waiting for Vulkan operations to complete using a swapchain derived from a different xcb connection referring to the same X server instance. Failing to do so may result in deadlock.

32.2.5. Xlib Platform

To create a VkSurfaceKHR object for an X11 window, using the Xlib client-side library, call:

VkResult vkCreateXlibSurfaceKHR(
    VkInstance                                  instance,
    const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

instance is the instance to associate the surface with.
pCreateInfo is a pointer to a VkXlibSurfaceCreateInfoKHR structure containing the parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface is a pointer to a VkSurfaceKHR handle in which the created surface object is returned.

Valid Usage (Implicit)

VUID-vkCreateXlibSurfaceKHR-instance-parameter
instance must be a valid VkInstance handle
VUID-vkCreateXlibSurfaceKHR-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkXlibSurfaceCreateInfoKHR structure
VUID-vkCreateXlibSurfaceKHR-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateXlibSurfaceKHR-pSurface-parameter
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkXlibSurfaceCreateInfoKHR structure is defined as:

typedef struct VkXlibSurfaceCreateInfoKHR {
    VkStructureType                sType;
    const void*                    pNext;
    VkXlibSurfaceCreateFlagsKHR    flags;
    Display*                       dpy;
    Window                         window;
} VkXlibSurfaceCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
dpy is a pointer to an Xlib Display connection to the X server.
window is an Xlib Window to associate the surface with.

Valid Usage

VUID-VkXlibSurfaceCreateInfoKHR-dpy-01313
dpy must point to a valid Xlib Display.
VUID-VkXlibSurfaceCreateInfoKHR-window-01314
window must be a valid Xlib Window.

Valid Usage (Implicit)

VUID-VkXlibSurfaceCreateInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR
VUID-VkXlibSurfaceCreateInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkXlibSurfaceCreateInfoKHR-flags-zerobitmask
flags must be 0

With Xlib, minImageExtent, maxImageExtent, and currentExtent must always equal the window size.

The currentExtent of an Xlib surface must have both width and height greater than 0, or both of them 0.

Note

Due to above restrictions, it is only possible to create a new swapchain on this platform with imageExtent being equal to the current size of the window.

The window size may become (0, 0) on this platform (e.g. when the window is minimized), and so a swapchain cannot be created until the size changes.

Some Vulkan functions may send protocol over the specified Xlib Display connection when using a swapchain or presentable images created from a VkSurfaceKHR referring to an Xlib window. Applications must therefore ensure the display connection is available to Vulkan for the duration of any functions that manipulate such swapchains or their presentable images, and any functions that build or queue command buffers that operate on such presentable images. Specifically, applications using Vulkan with Xlib-based swapchains must

Avoid holding a server grab on a display connection while waiting for Vulkan operations to complete using a swapchain derived from a different display connection referring to the same X server instance. Failing to do so may result in deadlock.

Some implementations may require threads to implement some presentation modes so applications must call XInitThreads() before calling any other Xlib functions.

32.2.6. Fuchsia Platform

To create a VkSurfaceKHR object for a Fuchsia ImagePipe, call:

VkResult vkCreateImagePipeSurfaceFUCHSIA(
    VkInstance                                  instance,
    const VkImagePipeSurfaceCreateInfoFUCHSIA*  pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

instance is the instance to associate with the surface.
pCreateInfo is a pointer to a VkImagePipeSurfaceCreateInfoFUCHSIA structure containing parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface is a pointer to a VkSurfaceKHR handle in which the created surface object is returned.

Valid Usage (Implicit)

VUID-vkCreateImagePipeSurfaceFUCHSIA-instance-parameter
instance must be a valid VkInstance handle
VUID-vkCreateImagePipeSurfaceFUCHSIA-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkImagePipeSurfaceCreateInfoFUCHSIA structure
VUID-vkCreateImagePipeSurfaceFUCHSIA-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateImagePipeSurfaceFUCHSIA-pSurface-parameter
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkImagePipeSurfaceCreateInfoFUCHSIA structure is defined as:

typedef struct VkImagePipeSurfaceCreateInfoFUCHSIA {
    VkStructureType                         sType;
    const void*                             pNext;
    VkImagePipeSurfaceCreateFlagsFUCHSIA    flags;
    zx_handle_t                             imagePipeHandle;
} VkImagePipeSurfaceCreateInfoFUCHSIA;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
imagePipeHandle is a zx_handle_t referring to the ImagePipe to associate with the surface.

Valid Usage

VUID-VkImagePipeSurfaceCreateInfoFUCHSIA-imagePipeHandle-00000
imagePipeHandle must be a valid zx_handle_t

Valid Usage (Implicit)

VUID-VkImagePipeSurfaceCreateInfoFUCHSIA-sType-sType
sType must be VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA
VUID-VkImagePipeSurfaceCreateInfoFUCHSIA-pNext-pNext
pNext must be NULL
VUID-VkImagePipeSurfaceCreateInfoFUCHSIA-flags-zerobitmask
flags must be 0

On Fuchsia, the surface currentExtent is the special value (0xFFFFFFFF, 0xFFFFFFFF), indicating that the surface size will be determined by the extent of a swapchain targeting the surface.

32.2.7. Google Games Platform

To create a VkSurfaceKHR object for a Google Games Platform stream descriptor, call:

VkResult vkCreateStreamDescriptorSurfaceGGP(
    VkInstance                                  instance,
    const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

instance is the instance to associate with the surface.
pCreateInfo is a pointer to a VkStreamDescriptorSurfaceCreateInfoGGP structure containing parameters that affect the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface is a pointer to a VkSurfaceKHR handle in which the created surface object is returned.

Valid Usage (Implicit)

VUID-vkCreateStreamDescriptorSurfaceGGP-instance-parameter
instance must be a valid VkInstance handle
VUID-vkCreateStreamDescriptorSurfaceGGP-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkStreamDescriptorSurfaceCreateInfoGGP structure
VUID-vkCreateStreamDescriptorSurfaceGGP-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateStreamDescriptorSurfaceGGP-pSurface-parameter
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR

The VkStreamDescriptorSurfaceCreateInfoGGP structure is defined as:

typedef struct VkStreamDescriptorSurfaceCreateInfoGGP {
    VkStructureType                            sType;
    const void*                                pNext;
    VkStreamDescriptorSurfaceCreateFlagsGGP    flags;
    GgpStreamDescriptor                        streamDescriptor;
} VkStreamDescriptorSurfaceCreateInfoGGP;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
streamDescriptor is a GgpStreamDescriptor referring to the GGP stream descriptor to associate with the surface.

Valid Usage

VUID-VkStreamDescriptorSurfaceCreateInfoGGP-streamDescriptor-02681
streamDescriptor must be a valid GgpStreamDescriptor

Valid Usage (Implicit)

VUID-VkStreamDescriptorSurfaceCreateInfoGGP-sType-sType
sType must be VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP
VUID-VkStreamDescriptorSurfaceCreateInfoGGP-pNext-pNext
pNext must be NULL
VUID-VkStreamDescriptorSurfaceCreateInfoGGP-flags-zerobitmask
flags must be 0

On Google Games Platform, the surface extents are dynamic. The minImageExtent will never be greater than 1080p and the maxImageExtent will never be less than 1080p. The currentExtent will reflect the current optimal resolution.

Applications are expected to choose an appropriate size for the swapchain’s imageExtent, within the bounds of the surface. Using the surface’s currentExtent will offer the best performance and quality. When a swapchain’s imageExtent does not match the surface’s currentExtent, the presentable images are scaled to the surface’s dimensions during presentation if possible and VK_SUBOPTIMAL_KHR is returned, otherwise presentation fails with VK_ERROR_OUT_OF_DATE_KHR.

32.2.8. iOS Platform

To create a VkSurfaceKHR object for an iOS UIView, call:

VkResult vkCreateIOSSurfaceMVK(
    VkInstance                                  instance,
    const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

instance is the instance with which to associate the surface.
pCreateInfo is a pointer to a VkIOSSurfaceCreateInfoMVK structure containing parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface is a pointer to a VkSurfaceKHR handle in which the created surface object is returned.

Valid Usage (Implicit)

VUID-vkCreateIOSSurfaceMVK-instance-parameter
instance must be a valid VkInstance handle
VUID-vkCreateIOSSurfaceMVK-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkIOSSurfaceCreateInfoMVK structure
VUID-vkCreateIOSSurfaceMVK-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateIOSSurfaceMVK-pSurface-parameter
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR

The VkIOSSurfaceCreateInfoMVK structure is defined as:

typedef struct VkIOSSurfaceCreateInfoMVK {
    VkStructureType               sType;
    const void*                   pNext;
    VkIOSSurfaceCreateFlagsMVK    flags;
    const void*                   pView;
} VkIOSSurfaceCreateInfoMVK;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
pView is a reference to a UIView object which will display this surface. This UIView must be backed by a CALayer instance of type CAMetalLayer.

Valid Usage

VUID-VkIOSSurfaceCreateInfoMVK-pView-01316
pView must be a valid UIView and must be backed by a CALayer instance of type CAMetalLayer.

Valid Usage (Implicit)

VUID-VkIOSSurfaceCreateInfoMVK-sType-sType
sType must be VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK
VUID-VkIOSSurfaceCreateInfoMVK-pNext-pNext
pNext must be NULL
VUID-VkIOSSurfaceCreateInfoMVK-flags-zerobitmask
flags must be 0

32.2.9. macOS Platform

To create a VkSurfaceKHR object for a macOS NSView, call:

VkResult vkCreateMacOSSurfaceMVK(
    VkInstance                                  instance,
    const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

instance is the instance with which to associate the surface.
pCreateInfo is a pointer to a VkMacOSSurfaceCreateInfoMVK structure containing parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface is a pointer to a VkSurfaceKHR handle in which the created surface object is returned.

Valid Usage (Implicit)

VUID-vkCreateMacOSSurfaceMVK-instance-parameter
instance must be a valid VkInstance handle
VUID-vkCreateMacOSSurfaceMVK-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkMacOSSurfaceCreateInfoMVK structure
VUID-vkCreateMacOSSurfaceMVK-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateMacOSSurfaceMVK-pSurface-parameter
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR

The VkMacOSSurfaceCreateInfoMVK structure is defined as:

typedef struct VkMacOSSurfaceCreateInfoMVK {
    VkStructureType                 sType;
    const void*                     pNext;
    VkMacOSSurfaceCreateFlagsMVK    flags;
    const void*                     pView;
} VkMacOSSurfaceCreateInfoMVK;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
pView is a reference to a NSView object which will display this surface. This NSView must be backed by a CALayer instance of type CAMetalLayer.

Valid Usage

VUID-VkMacOSSurfaceCreateInfoMVK-pView-01317
pView must be a valid NSView and must be backed by a CALayer instance of type CAMetalLayer.

Valid Usage (Implicit)

VUID-VkMacOSSurfaceCreateInfoMVK-sType-sType
sType must be VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK
VUID-VkMacOSSurfaceCreateInfoMVK-pNext-pNext
pNext must be NULL
VUID-VkMacOSSurfaceCreateInfoMVK-flags-zerobitmask
flags must be 0

32.2.10. VI Platform

To create a VkSurfaceKHR object for an nn::vi::Layer, query the layer’s native handle using nn::vi::GetNativeWindow, and then call:

VkResult vkCreateViSurfaceNN(
    VkInstance                                  instance,
    const VkViSurfaceCreateInfoNN*              pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

instance is the instance with which to associate the surface.
pCreateInfo is a pointer to a VkViSurfaceCreateInfoNN structure containing parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface is a pointer to a VkSurfaceKHR handle in which the created surface object is returned.

During the lifetime of a surface created using a particular nn::vi::NativeWindowHandle, applications must not attempt to create another surface for the same nn::vi::Layer or attempt to connect to the same nn::vi::Layer through other platform mechanisms.

If the native window is created with a specified size, currentExtent will reflect that size. In this case, applications should use the same size for the swapchain’s imageExtent. Otherwise, the currentExtent will have the special value (0xFFFFFFFF, 0xFFFFFFFF), indicating that applications are expected to choose an appropriate size for the swapchain’s imageExtent (e.g., by matching the result of a call to nn::vi::GetDisplayResolution).

Valid Usage (Implicit)

VUID-vkCreateViSurfaceNN-instance-parameter
instance must be a valid VkInstance handle
VUID-vkCreateViSurfaceNN-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkViSurfaceCreateInfoNN structure
VUID-vkCreateViSurfaceNN-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateViSurfaceNN-pSurface-parameter
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR

The VkViSurfaceCreateInfoNN structure is defined as:

typedef struct VkViSurfaceCreateInfoNN {
    VkStructureType             sType;
    const void*                 pNext;
    VkViSurfaceCreateFlagsNN    flags;
    void*                       window;
} VkViSurfaceCreateInfoNN;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
window is the nn::vi::NativeWindowHandle for the nn::vi::Layer with which to associate the surface.

Valid Usage

VUID-VkViSurfaceCreateInfoNN-window-01318
window must be a valid nn::vi::NativeWindowHandle

Valid Usage (Implicit)

VUID-VkViSurfaceCreateInfoNN-sType-sType
sType must be VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN
VUID-VkViSurfaceCreateInfoNN-pNext-pNext
pNext must be NULL
VUID-VkViSurfaceCreateInfoNN-flags-zerobitmask
flags must be 0

32.2.11. Metal Platform

To create a VkSurfaceKHR object for a CAMetalLayer, call:

VkResult vkCreateMetalSurfaceEXT(
    VkInstance                                  instance,
    const VkMetalSurfaceCreateInfoEXT*          pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

instance is the instance with which to associate the surface.
pCreateInfo is a pointer to a VkMetalSurfaceCreateInfoEXT structure specifying parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface is a pointer to a VkSurfaceKHR handle in which the created surface object is returned.

Valid Usage (Implicit)

VUID-vkCreateMetalSurfaceEXT-instance-parameter
instance must be a valid VkInstance handle
VUID-vkCreateMetalSurfaceEXT-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkMetalSurfaceCreateInfoEXT structure
VUID-vkCreateMetalSurfaceEXT-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateMetalSurfaceEXT-pSurface-parameter
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR

The VkMetalSurfaceCreateInfoEXT structure is defined as:

typedef struct VkMetalSurfaceCreateInfoEXT {
    VkStructureType                 sType;
    const void*                     pNext;
    VkMetalSurfaceCreateFlagsEXT    flags;
    const CAMetalLayer*             pLayer;
} VkMetalSurfaceCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.
pLayer is a reference to a CAMetalLayer object representing a renderable surface.

Valid Usage (Implicit)

VUID-VkMetalSurfaceCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT
VUID-VkMetalSurfaceCreateInfoEXT-pNext-pNext
pNext must be NULL
VUID-VkMetalSurfaceCreateInfoEXT-flags-zerobitmask
flags must be 0

To remove an unnecessary compile-time dependency, an incomplete type definition of CAMetalLayer is provided in the Vulkan headers:

#ifdef __OBJC__
@class CAMetalLayer;
#else
typedef void CAMetalLayer;
#endif

The actual CAMetalLayer type is defined in the QuartzCore framework.

32.2.12. Platform-Independent Information

Once created, VkSurfaceKHR objects can be used in this and other extensions, in particular the VK_KHR_swapchain extension.

Several WSI functions return VK_ERROR_SURFACE_LOST_KHR if the surface becomes no longer available. After such an error, the surface (and any child swapchain, if one exists) should be destroyed, as there is no way to restore them to a not-lost state. Applications may attempt to create a new VkSurfaceKHR using the same native platform window object, but whether such re-creation will succeed is platform-dependent and may depend on the reason the surface became unavailable. A lost surface does not otherwise cause devices to be lost.

To destroy a VkSurfaceKHR object, call:

void vkDestroySurfaceKHR(
    VkInstance                                  instance,
    VkSurfaceKHR                                surface,
    const VkAllocationCallbacks*                pAllocator);

instance is the instance used to create the surface.
surface is the surface to destroy.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).

Destroying a VkSurfaceKHR merely severs the connection between Vulkan and the native surface, and does not imply destroying the native surface, closing a window, or similar behavior.

Valid Usage

VUID-vkDestroySurfaceKHR-surface-01266
All VkSwapchainKHR objects created for surface must have been destroyed prior to destroying surface
VUID-vkDestroySurfaceKHR-surface-01267
If VkAllocationCallbacks were provided when surface was created, a compatible set of callbacks must be provided here
VUID-vkDestroySurfaceKHR-surface-01268
If no VkAllocationCallbacks were provided when surface was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroySurfaceKHR-instance-parameter
instance must be a valid VkInstance handle
VUID-vkDestroySurfaceKHR-surface-parameter
If surface is not VK_NULL_HANDLE, surface must be a valid VkSurfaceKHR handle
VUID-vkDestroySurfaceKHR-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroySurfaceKHR-surface-parent
If surface is a valid handle, it must have been created, allocated, or retrieved from instance

Host Synchronization

Host access to surface must be externally synchronized

32.3. Presenting Directly to Display Devices

In some environments applications can also present Vulkan rendering directly to display devices without using an intermediate windowing system. This can be useful for embedded applications, or implementing the rendering/presentation backend of a windowing system using Vulkan. The VK_KHR_display extension provides the functionality necessary to enumerate display devices and create VkSurfaceKHR objects that target displays.

32.3.1. Display Enumeration

Displays are represented by VkDisplayKHR handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)

Various functions are provided for enumerating the available display devices present on a Vulkan physical device. To query information about the available displays, call:

VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pPropertyCount,
    VkDisplayPropertiesKHR*                     pProperties);

physicalDevice is a physical device.
pPropertyCount is a pointer to an integer related to the number of display devices available or queried, as described below.
pProperties is either NULL or a pointer to an array of VkDisplayPropertiesKHR structures.

If pProperties is NULL, then the number of display devices available for physicalDevice 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 display devices for physicalDevice, at most pPropertyCount structures will be written. If pPropertyCount is smaller than the number of display devices available for physicalDevice, VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pPropertyCount-parameter
pPropertyCount must be a valid pointer to a uint32_t value
VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pProperties-parameter
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPropertiesKHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkDisplayPropertiesKHR structure is defined as:

typedef struct VkDisplayPropertiesKHR {
    VkDisplayKHR                  display;
    const char*                   displayName;
    VkExtent2D                    physicalDimensions;
    VkExtent2D                    physicalResolution;
    VkSurfaceTransformFlagsKHR    supportedTransforms;
    VkBool32                      planeReorderPossible;
    VkBool32                      persistentContent;
} VkDisplayPropertiesKHR;

display is a handle that is used to refer to the display described here. This handle will be valid for the lifetime of the Vulkan instance.
displayName is a pointer to a null-terminated UTF-8 string containing the name of the display. Generally, this will be the name provided by the display’s EDID. It can be NULL if no suitable name is available. If not NULL, the memory it points to must remain accessible as long as display is valid.
physicalDimensions describes the physical width and height of the visible portion of the display, in millimeters.
physicalResolution describes the physical, native, or preferred resolution of the display.

Note

For devices which have no natural value to return here, implementations should return the maximum resolution supported.

supportedTransforms is a bitmask of VkSurfaceTransformFlagBitsKHR describing which transforms are supported by this display.
planeReorderPossible tells whether the planes on this display can have their z order changed. If this is VK_TRUE, the application can re-arrange the planes on this display in any order relative to each other.
persistentContent tells whether the display supports self-refresh/internal buffering. If this is true, the application can submit persistent present operations on swapchains created against this display.

Note

Persistent presents may have higher latency, and may use less power when the screen content is updated infrequently, or when only a portion of the screen needs to be updated in most frames.

To query information about the available displays, call:

VkResult vkGetPhysicalDeviceDisplayProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pPropertyCount,
    VkDisplayProperties2KHR*                    pProperties);

physicalDevice is a physical device.
pPropertyCount is a pointer to an integer related to the number of display devices available or queried, as described below.
pProperties is either NULL or a pointer to an array of VkDisplayProperties2KHR structures.

vkGetPhysicalDeviceDisplayProperties2KHR behaves similarly to vkGetPhysicalDeviceDisplayPropertiesKHR, with the ability to return extended information via chained output structures.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceDisplayProperties2KHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceDisplayProperties2KHR-pPropertyCount-parameter
pPropertyCount must be a valid pointer to a uint32_t value
VUID-vkGetPhysicalDeviceDisplayProperties2KHR-pProperties-parameter
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayProperties2KHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkDisplayProperties2KHR structure is defined as:

typedef struct VkDisplayProperties2KHR {
    VkStructureType           sType;
    void*                     pNext;
    VkDisplayPropertiesKHR    displayProperties;
} VkDisplayProperties2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
displayProperties is a VkDisplayPropertiesKHR structure.

Valid Usage (Implicit)

VUID-VkDisplayProperties2KHR-sType-sType
sType must be VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR
VUID-VkDisplayProperties2KHR-pNext-pNext
pNext must be NULL

Acquiring and Releasing Displays

On some platforms, access to displays is limited to a single process or native driver instance. On such platforms, some or all of the displays may not be available to Vulkan if they are already in use by a native windowing system or other application.

To acquire permission to directly access a display in Vulkan from an X11 server, call:

VkResult vkAcquireXlibDisplayEXT(
    VkPhysicalDevice                            physicalDevice,
    Display*                                    dpy,
    VkDisplayKHR                                display);

physicalDevice The physical device the display is on.
dpy A connection to the X11 server that currently owns display.
display The display the caller wishes to control in Vulkan.

All permissions necessary to control the display are granted to the Vulkan instance associated with physicalDevice until the display is released or the X11 connection specified by dpy is terminated. Permission to access the display may be temporarily revoked during periods when the X11 server from which control was acquired itself loses access to display. During such periods, operations which require access to the display must fail with an approriate error code. If the X11 server associated with dpy does not own display, or if permission to access it has already been acquired by another entity, the call must return the error code VK_ERROR_INITIALIZATION_FAILED.

Note

One example of when an X11 server loses access to a display is when it loses ownership of its virtual terminal.

Valid Usage (Implicit)

VUID-vkAcquireXlibDisplayEXT-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkAcquireXlibDisplayEXT-dpy-parameter
dpy must be a valid pointer to a Display value
VUID-vkAcquireXlibDisplayEXT-display-parameter
display must be a valid VkDisplayKHR handle

Return Codes

VK_SUCCESS

VK_ERROR_INITIALIZATION_FAILED

When acquiring displays from an X11 server, an application may also wish to enumerate and identify them using a native handle rather than a VkDisplayKHR handle. To determine the VkDisplayKHR handle corresponding to an X11 RandR Output, call:

VkResult vkGetRandROutputDisplayEXT(
    VkPhysicalDevice                            physicalDevice,
    Display*                                    dpy,
    RROutput                                    rrOutput,
    VkDisplayKHR*                               pDisplay);

physicalDevice The physical device to query the display handle on.
dpy A connection to the X11 server from which rrOutput was queried.
rrOutput An X11 RandR output ID.
pDisplay The corresponding VkDisplayKHR handle will be returned here.

If there is no VkDisplayKHR corresponding to rrOutput on physicalDevice, VK_NULL_HANDLE must be returned in pDisplay.

Valid Usage (Implicit)

VUID-vkGetRandROutputDisplayEXT-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetRandROutputDisplayEXT-dpy-parameter
dpy must be a valid pointer to a Display value
VUID-vkGetRandROutputDisplayEXT-pDisplay-parameter
pDisplay must be a valid pointer to a VkDisplayKHR handle

Return Codes

VK_SUCCESS

To release a previously acquired display, call:

VkResult vkReleaseDisplayEXT(
    VkPhysicalDevice                            physicalDevice,
    VkDisplayKHR                                display);

physicalDevice The physical device the display is on.
display The display to release control of.

Valid Usage (Implicit)

VUID-vkReleaseDisplayEXT-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkReleaseDisplayEXT-display-parameter
display must be a valid VkDisplayKHR handle

Return Codes

VK_SUCCESS

Display Planes

Images are presented to individual planes on a display. Devices must support at least one plane on each display. Planes can be stacked and blended to composite multiple images on one display. Devices may support only a fixed stacking order and fixed mapping between planes and displays, or they may allow arbitrary application specified stacking orders and mappings between planes and displays. To query the properties of device display planes, call:

VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pPropertyCount,
    VkDisplayPlanePropertiesKHR*                pProperties);

physicalDevice is a physical device.
pPropertyCount is a pointer to an integer related to the number of display planes available or queried, as described below.
pProperties is either NULL or a pointer to an array of VkDisplayPlanePropertiesKHR structures.

If pProperties is NULL, then the number of display planes available for physicalDevice 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 display planes for physicalDevice, at most pPropertyCount structures will be written.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-pPropertyCount-parameter
pPropertyCount must be a valid pointer to a uint32_t value
VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-pProperties-parameter
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPlanePropertiesKHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkDisplayPlanePropertiesKHR structure is defined as:

typedef struct VkDisplayPlanePropertiesKHR {
    VkDisplayKHR    currentDisplay;
    uint32_t        currentStackIndex;
} VkDisplayPlanePropertiesKHR;

currentDisplay is the handle of the display the plane is currently associated with. If the plane is not currently attached to any displays, this will be VK_NULL_HANDLE.
currentStackIndex is the current z-order of the plane. This will be between 0 and the value returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR in pPropertyCount.

To query the properties of a device’s display planes, call:

VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pPropertyCount,
    VkDisplayPlaneProperties2KHR*               pProperties);

physicalDevice is a physical device.
pPropertyCount is a pointer to an integer related to the number of display planes available or queried, as described below.
pProperties is either NULL or a pointer to an array of VkDisplayPlaneProperties2KHR structures.

vkGetPhysicalDeviceDisplayPlaneProperties2KHR behaves similarly to vkGetPhysicalDeviceDisplayPlanePropertiesKHR, with the ability to return extended information via chained output structures.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-pPropertyCount-parameter
pPropertyCount must be a valid pointer to a uint32_t value
VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-pProperties-parameter
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPlaneProperties2KHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkDisplayPlaneProperties2KHR structure is defined as:

typedef struct VkDisplayPlaneProperties2KHR {
    VkStructureType                sType;
    void*                          pNext;
    VkDisplayPlanePropertiesKHR    displayPlaneProperties;
} VkDisplayPlaneProperties2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
displayPlaneProperties is a VkDisplayPlanePropertiesKHR structure.

Valid Usage (Implicit)

VUID-VkDisplayPlaneProperties2KHR-sType-sType
sType must be VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR
VUID-VkDisplayPlaneProperties2KHR-pNext-pNext
pNext must be NULL

To determine which displays a plane is usable with, call

VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t                                    planeIndex,
    uint32_t*                                   pDisplayCount,
    VkDisplayKHR*                               pDisplays);

physicalDevice is a physical device.
planeIndex is the plane which the application wishes to use, and must be in the range [0, physical device plane count - 1].
pDisplayCount is a pointer to an integer related to the number of displays available or queried, as described below.
pDisplays is either NULL or a pointer to an array of VkDisplayKHR handles.

If pDisplays is NULL, then the number of displays usable with the specified planeIndex for physicalDevice is returned in pDisplayCount. Otherwise, pDisplayCount must point to a variable set by the user to the number of elements in the pDisplays array, and on return the variable is overwritten with the number of handles actually written to pDisplays. If the value of pDisplayCount is less than the number of display planes for physicalDevice, at most pDisplayCount handles will be written. If pDisplayCount is smaller than the number of displays usable with the specified planeIndex for physicalDevice, VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned.

Valid Usage

VUID-vkGetDisplayPlaneSupportedDisplaysKHR-planeIndex-01249
planeIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR

Valid Usage (Implicit)

VUID-vkGetDisplayPlaneSupportedDisplaysKHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetDisplayPlaneSupportedDisplaysKHR-pDisplayCount-parameter
pDisplayCount must be a valid pointer to a uint32_t value
VUID-vkGetDisplayPlaneSupportedDisplaysKHR-pDisplays-parameter
If the value referenced by pDisplayCount is not 0, and pDisplays is not NULL, pDisplays must be a valid pointer to an array of pDisplayCount VkDisplayKHR handles

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Additional properties of displays are queried using specialized query functions.

Display Modes

Display modes are represented by VkDisplayModeKHR handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)

Each display has one or more supported modes associated with it by default. These built-in modes are queried by calling:

VkResult vkGetDisplayModePropertiesKHR(
    VkPhysicalDevice                            physicalDevice,
    VkDisplayKHR                                display,
    uint32_t*                                   pPropertyCount,
    VkDisplayModePropertiesKHR*                 pProperties);

physicalDevice is the physical device associated with display.
display is the display to query.
pPropertyCount is a pointer to an integer related to the number of display modes available or queried, as described below.
pProperties is either NULL or a pointer to an array of VkDisplayModePropertiesKHR structures.

If pProperties is NULL, then the number of display modes available on the specified display for physicalDevice 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 display modes for physicalDevice, at most pPropertyCount structures will be written. If pPropertyCount is smaller than the number of display modes available on the specified display for physicalDevice, VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned.

Valid Usage (Implicit)

VUID-vkGetDisplayModePropertiesKHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetDisplayModePropertiesKHR-display-parameter
display must be a valid VkDisplayKHR handle
VUID-vkGetDisplayModePropertiesKHR-pPropertyCount-parameter
pPropertyCount must be a valid pointer to a uint32_t value
VUID-vkGetDisplayModePropertiesKHR-pProperties-parameter
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayModePropertiesKHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkDisplayModePropertiesKHR structure is defined as:

typedef struct VkDisplayModePropertiesKHR {
    VkDisplayModeKHR              displayMode;
    VkDisplayModeParametersKHR    parameters;
} VkDisplayModePropertiesKHR;

displayMode is a handle to the display mode described in this structure. This handle will be valid for the lifetime of the Vulkan instance.
parameters is a VkDisplayModeParametersKHR structure describing the display parameters associated with displayMode.

typedef VkFlags VkDisplayModeCreateFlagsKHR;

VkDisplayModeCreateFlagsKHR is a bitmask type for setting a mask, but is currently reserved for future use.

To query the properties of a device’s built-in display modes, call:

VkResult vkGetDisplayModeProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    VkDisplayKHR                                display,
    uint32_t*                                   pPropertyCount,
    VkDisplayModeProperties2KHR*                pProperties);

physicalDevice is the physical device associated with display.
display is the display to query.
pPropertyCount is a pointer to an integer related to the number of display modes available or queried, as described below.
pProperties is either NULL or a pointer to an array of VkDisplayModeProperties2KHR structures.

vkGetDisplayModeProperties2KHR behaves similarly to vkGetDisplayModePropertiesKHR, with the ability to return extended information via chained output structures.

Valid Usage (Implicit)

VUID-vkGetDisplayModeProperties2KHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetDisplayModeProperties2KHR-display-parameter
display must be a valid VkDisplayKHR handle
VUID-vkGetDisplayModeProperties2KHR-pPropertyCount-parameter
pPropertyCount must be a valid pointer to a uint32_t value
VUID-vkGetDisplayModeProperties2KHR-pProperties-parameter
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayModeProperties2KHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkDisplayModeProperties2KHR structure is defined as:

typedef struct VkDisplayModeProperties2KHR {
    VkStructureType               sType;
    void*                         pNext;
    VkDisplayModePropertiesKHR    displayModeProperties;
} VkDisplayModeProperties2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
displayModeProperties is a VkDisplayModePropertiesKHR structure.

Valid Usage (Implicit)

VUID-VkDisplayModeProperties2KHR-sType-sType
sType must be VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR
VUID-VkDisplayModeProperties2KHR-pNext-pNext
pNext must be NULL

The VkDisplayModeParametersKHR structure is defined as:

typedef struct VkDisplayModeParametersKHR {
    VkExtent2D    visibleRegion;
    uint32_t      refreshRate;
} VkDisplayModeParametersKHR;

visibleRegion is the 2D extents of the visible region.
refreshRate is a uint32_t that is the number of times the display is refreshed each second multiplied by 1000.

Note

For example, a 60Hz display mode would report a refreshRate of 60,000.

Valid Usage

VUID-VkDisplayModeParametersKHR-width-01990
The width member of visibleRegion must be greater than 0
VUID-VkDisplayModeParametersKHR-height-01991
The height member of visibleRegion must be greater than 0
VUID-VkDisplayModeParametersKHR-refreshRate-01992
refreshRate must be greater than 0

Additional modes may also be created by calling:

VkResult vkCreateDisplayModeKHR(
    VkPhysicalDevice                            physicalDevice,
    VkDisplayKHR                                display,
    const VkDisplayModeCreateInfoKHR*           pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkDisplayModeKHR*                           pMode);

physicalDevice is the physical device associated with display.
display is the display to create an additional mode for.
pCreateInfo is a VkDisplayModeCreateInfoKHR structure describing the new mode to create.
pAllocator is the allocator used for host memory allocated for the display mode object when there is no more specific allocator available (see Memory Allocation).
pMode returns the handle of the mode created.

Valid Usage (Implicit)

VUID-vkCreateDisplayModeKHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkCreateDisplayModeKHR-display-parameter
display must be a valid VkDisplayKHR handle
VUID-vkCreateDisplayModeKHR-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkDisplayModeCreateInfoKHR structure
VUID-vkCreateDisplayModeKHR-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateDisplayModeKHR-pMode-parameter
pMode must be a valid pointer to a VkDisplayModeKHR handle

Host Synchronization

Host access to display must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INITIALIZATION_FAILED

The VkDisplayModeCreateInfoKHR structure is defined as:

typedef struct VkDisplayModeCreateInfoKHR {
    VkStructureType                sType;
    const void*                    pNext;
    VkDisplayModeCreateFlagsKHR    flags;
    VkDisplayModeParametersKHR     parameters;
} VkDisplayModeCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use, and must be zero.
parameters is a VkDisplayModeParametersKHR structure describing the display parameters to use in creating the new mode. If the parameters are not compatible with the specified display, the implementation must return VK_ERROR_INITIALIZATION_FAILED.

Valid Usage (Implicit)

VUID-VkDisplayModeCreateInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR
VUID-VkDisplayModeCreateInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkDisplayModeCreateInfoKHR-flags-zerobitmask
flags must be 0
VUID-VkDisplayModeCreateInfoKHR-parameters-parameter
parameters must be a valid VkDisplayModeParametersKHR structure

Applications that wish to present directly to a display must select which layer, or “plane” of the display they wish to target, and a mode to use with the display. Each display supports at least one plane. The capabilities of a given mode and plane combination are determined by calling:

VkResult vkGetDisplayPlaneCapabilitiesKHR(
    VkPhysicalDevice                            physicalDevice,
    VkDisplayModeKHR                            mode,
    uint32_t                                    planeIndex,
    VkDisplayPlaneCapabilitiesKHR*              pCapabilities);

physicalDevice is the physical device associated with display
mode is the display mode the application intends to program when using the specified plane. Note this parameter also implicitly specifies a display.
planeIndex is the plane which the application intends to use with the display, and is less than the number of display planes supported by the device.
pCapabilities is a pointer to a VkDisplayPlaneCapabilitiesKHR structure in which the capabilities are returned.

Valid Usage (Implicit)

VUID-vkGetDisplayPlaneCapabilitiesKHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetDisplayPlaneCapabilitiesKHR-mode-parameter
mode must be a valid VkDisplayModeKHR handle
VUID-vkGetDisplayPlaneCapabilitiesKHR-pCapabilities-parameter
pCapabilities must be a valid pointer to a VkDisplayPlaneCapabilitiesKHR structure

Host Synchronization

Host access to mode must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkDisplayPlaneCapabilitiesKHR structure is defined as:

typedef struct VkDisplayPlaneCapabilitiesKHR {
    VkDisplayPlaneAlphaFlagsKHR    supportedAlpha;
    VkOffset2D                     minSrcPosition;
    VkOffset2D                     maxSrcPosition;
    VkExtent2D                     minSrcExtent;
    VkExtent2D                     maxSrcExtent;
    VkOffset2D                     minDstPosition;
    VkOffset2D                     maxDstPosition;
    VkExtent2D                     minDstExtent;
    VkExtent2D                     maxDstExtent;
} VkDisplayPlaneCapabilitiesKHR;

supportedAlpha is a bitmask of VkDisplayPlaneAlphaFlagBitsKHR describing the supported alpha blending modes.
minSrcPosition is the minimum source rectangle offset supported by this plane using the specified mode.
maxSrcPosition is the maximum source rectangle offset supported by this plane using the specified mode. The x and y components of maxSrcPosition must each be greater than or equal to the x and y components of minSrcPosition, respectively.
minSrcExtent is the minimum source rectangle size supported by this plane using the specified mode.
maxSrcExtent is the maximum source rectangle size supported by this plane using the specified mode.
minDstPosition, maxDstPosition, minDstExtent, maxDstExtent all have similar semantics to their corresponding *Src* equivalents, but apply to the output region within the mode rather than the input region within the source image. Unlike the *Src* offsets, minDstPosition and maxDstPosition may contain negative values.

The minimum and maximum position and extent fields describe the implementation limits, if any, as they apply to the specified display mode and plane. Vendors may support displaying a subset of a swapchain’s presentable images on the specified display plane. This is expressed by returning minSrcPosition, maxSrcPosition, minSrcExtent, and maxSrcExtent values that indicate a range of possible positions and sizes may be used to specify the region within the presentable images that source pixels will be read from when creating a swapchain on the specified display mode and plane.

Vendors may also support mapping the presentable images’ content to a subset or superset of the visible region in the specified display mode. This is expressed by returning minDstPosition, maxDstPosition, minDstExtent and maxDstExtent values that indicate a range of possible positions and sizes may be used to describe the region within the display mode that the source pixels will be mapped to.

Other vendors may support only a 1-1 mapping between pixels in the presentable images and the display mode. This may be indicated by returning (0,0) for minSrcPosition, maxSrcPosition, minDstPosition, and maxDstPosition, and (display mode width, display mode height) for minSrcExtent, maxSrcExtent, minDstExtent, and maxDstExtent.

These values indicate the limits of the implementation’s individual fields. Not all combinations of values within the offset and extent ranges returned in VkDisplayPlaneCapabilitiesKHR are guaranteed to be supported. Presentation requests specifying unsupported combinations may fail.

To query the capabilities of a given mode and plane combination, call:

VkResult vkGetDisplayPlaneCapabilities2KHR(
    VkPhysicalDevice                            physicalDevice,
    const VkDisplayPlaneInfo2KHR*               pDisplayPlaneInfo,
    VkDisplayPlaneCapabilities2KHR*             pCapabilities);

physicalDevice is the physical device associated with pDisplayPlaneInfo.
pDisplayPlaneInfo is a pointer to a VkDisplayPlaneInfo2KHR structure describing the plane and mode.
pCapabilities is a pointer to a VkDisplayPlaneCapabilities2KHR structure in which the capabilities are returned.

vkGetDisplayPlaneCapabilities2KHR behaves similarly to vkGetDisplayPlaneCapabilitiesKHR, with the ability to specify extended inputs via chained input structures, and to return extended information via chained output structures.

Valid Usage (Implicit)

VUID-vkGetDisplayPlaneCapabilities2KHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetDisplayPlaneCapabilities2KHR-pDisplayPlaneInfo-parameter
pDisplayPlaneInfo must be a valid pointer to a valid VkDisplayPlaneInfo2KHR structure
VUID-vkGetDisplayPlaneCapabilities2KHR-pCapabilities-parameter
pCapabilities must be a valid pointer to a VkDisplayPlaneCapabilities2KHR structure

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkDisplayPlaneInfo2KHR structure is defined as:

typedef struct VkDisplayPlaneInfo2KHR {
    VkStructureType     sType;
    const void*         pNext;
    VkDisplayModeKHR    mode;
    uint32_t            planeIndex;
} VkDisplayPlaneInfo2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
mode is the display mode the application intends to program when using the specified plane.

Note

This parameter also implicitly specifies a display.

planeIndex is the plane which the application intends to use with the display.

The members of VkDisplayPlaneInfo2KHR correspond to the arguments to vkGetDisplayPlaneCapabilitiesKHR, with sType and pNext added for extensibility.

Valid Usage (Implicit)

VUID-VkDisplayPlaneInfo2KHR-sType-sType
sType must be VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR
VUID-VkDisplayPlaneInfo2KHR-pNext-pNext
pNext must be NULL
VUID-VkDisplayPlaneInfo2KHR-mode-parameter
mode must be a valid VkDisplayModeKHR handle

Host Synchronization

Host access to mode must be externally synchronized

The VkDisplayPlaneCapabilities2KHR structure is defined as:

typedef struct VkDisplayPlaneCapabilities2KHR {
    VkStructureType                  sType;
    void*                            pNext;
    VkDisplayPlaneCapabilitiesKHR    capabilities;
} VkDisplayPlaneCapabilities2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
capabilities is a VkDisplayPlaneCapabilitiesKHR structure.

Valid Usage (Implicit)

VUID-VkDisplayPlaneCapabilities2KHR-sType-sType
sType must be VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR
VUID-VkDisplayPlaneCapabilities2KHR-pNext-pNext
pNext must be NULL

32.3.2. Display Control

To set the power state of a display, call:

VkResult vkDisplayPowerControlEXT(
    VkDevice                                    device,
    VkDisplayKHR                                display,
    const VkDisplayPowerInfoEXT*                pDisplayPowerInfo);

device is a logical device associated with display.
display is the display whose power state is modified.
pDisplayPowerInfo is a VkDisplayPowerInfoEXT structure specifying the new power state of display.

Valid Usage (Implicit)

VUID-vkDisplayPowerControlEXT-device-parameter
device must be a valid VkDevice handle
VUID-vkDisplayPowerControlEXT-display-parameter
display must be a valid VkDisplayKHR handle
VUID-vkDisplayPowerControlEXT-pDisplayPowerInfo-parameter
pDisplayPowerInfo must be a valid pointer to a valid VkDisplayPowerInfoEXT structure

Return Codes

VK_SUCCESS

The VkDisplayPowerInfoEXT structure is defined as:

typedef struct VkDisplayPowerInfoEXT {
    VkStructureType           sType;
    const void*               pNext;
    VkDisplayPowerStateEXT    powerState;
} VkDisplayPowerInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
powerState is a VkDisplayPowerStateEXT value specifying the new power state of the display.

Valid Usage (Implicit)

VUID-VkDisplayPowerInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT
VUID-VkDisplayPowerInfoEXT-pNext-pNext
pNext must be NULL
VUID-VkDisplayPowerInfoEXT-powerState-parameter
powerState must be a valid VkDisplayPowerStateEXT value

Possible values of VkDisplayPowerInfoEXT::powerState, specifying the new power state of a display, are:

typedef enum VkDisplayPowerStateEXT {
    VK_DISPLAY_POWER_STATE_OFF_EXT = 0,
    VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1,
    VK_DISPLAY_POWER_STATE_ON_EXT = 2,
    VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF
} VkDisplayPowerStateEXT;

VK_DISPLAY_POWER_STATE_OFF_EXT specifies that the display is powered down.
VK_DISPLAY_POWER_STATE_SUSPEND_EXT specifies that the display is put into a low power mode, from which it may be able to transition back to VK_DISPLAY_POWER_STATE_ON_EXT more quickly than if it were in VK_DISPLAY_POWER_STATE_OFF_EXT. This state may be the same as VK_DISPLAY_POWER_STATE_OFF_EXT.
VK_DISPLAY_POWER_STATE_ON_EXT specifies that the display is powered on.

32.3.3. Display Surfaces

A complete display configuration includes a mode, one or more display planes and any parameters describing their behavior, and parameters describing some aspects of the images associated with those planes. Display surfaces describe the configuration of a single plane within a complete display configuration. To create a VkSurfaceKHR structure for a display surface, call:

VkResult vkCreateDisplayPlaneSurfaceKHR(
    VkInstance                                  instance,
    const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

instance is the instance corresponding to the physical device the targeted display is on.
pCreateInfo is a pointer to a VkDisplaySurfaceCreateInfoKHR structure specifying which mode, plane, and other parameters to use, as described below.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface is a pointer to a VkSurfaceKHR handle in which the created surface is returned.

Valid Usage (Implicit)

VUID-vkCreateDisplayPlaneSurfaceKHR-instance-parameter
instance must be a valid VkInstance handle
VUID-vkCreateDisplayPlaneSurfaceKHR-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkDisplaySurfaceCreateInfoKHR structure
VUID-vkCreateDisplayPlaneSurfaceKHR-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateDisplayPlaneSurfaceKHR-pSurface-parameter
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkDisplaySurfaceCreateInfoKHR structure is defined as:

typedef struct VkDisplaySurfaceCreateInfoKHR {
    VkStructureType                   sType;
    const void*                       pNext;
    VkDisplaySurfaceCreateFlagsKHR    flags;
    VkDisplayModeKHR                  displayMode;
    uint32_t                          planeIndex;
    uint32_t                          planeStackIndex;
    VkSurfaceTransformFlagBitsKHR     transform;
    float                             globalAlpha;
    VkDisplayPlaneAlphaFlagBitsKHR    alphaMode;
    VkExtent2D                        imageExtent;
} VkDisplaySurfaceCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use, and must be zero.
displayMode is a VkDisplayModeKHR handle specifying the mode to use when displaying this surface.
planeIndex is the plane on which this surface appears.
planeStackIndex is the z-order of the plane.
transform is a VkSurfaceTransformFlagBitsKHR value specifying the transformation to apply to images as part of the scanout operation.
globalAlpha is the global alpha value. This value is ignored if alphaMode is not VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR.
alphaMode is a VkDisplayPlaneAlphaFlagBitsKHR value specifying the type of alpha blending to use.
imageExtent The size of the presentable images to use with the surface.

Note

Creating a display surface must not modify the state of the displays, planes, or other resources it names. For example, it must not apply the specified mode to be set on the associated display. Application of display configuration occurs as a side effect of presenting to a display surface.

Valid Usage

VUID-VkDisplaySurfaceCreateInfoKHR-planeIndex-01252
planeIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR
VUID-VkDisplaySurfaceCreateInfoKHR-planeReorderPossible-01253
If the planeReorderPossible member of the VkDisplayPropertiesKHR structure returned by vkGetPhysicalDeviceDisplayPropertiesKHR for the display corresponding to displayMode is VK_TRUE then planeStackIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR; otherwise planeStackIndex must equal the currentStackIndex member of VkDisplayPlanePropertiesKHR returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR for the display plane corresponding to displayMode
VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-01254
If alphaMode is VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR then globalAlpha must be between 0 and 1, inclusive
VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-01255
alphaMode must be 0 or one of the bits present in the supportedAlpha member of VkDisplayPlaneCapabilitiesKHR returned by vkGetDisplayPlaneCapabilitiesKHR for the display plane corresponding to displayMode
VUID-VkDisplaySurfaceCreateInfoKHR-width-01256
The width and height members of imageExtent must be less than the maxImageDimensions2D member of VkPhysicalDeviceLimits

Valid Usage (Implicit)

VUID-VkDisplaySurfaceCreateInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR
VUID-VkDisplaySurfaceCreateInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkDisplaySurfaceCreateInfoKHR-flags-zerobitmask
flags must be 0
VUID-VkDisplaySurfaceCreateInfoKHR-displayMode-parameter
displayMode must be a valid VkDisplayModeKHR handle
VUID-VkDisplaySurfaceCreateInfoKHR-transform-parameter
transform must be a valid VkSurfaceTransformFlagBitsKHR value
VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-parameter
alphaMode must be a valid VkDisplayPlaneAlphaFlagBitsKHR value

typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;

VkDisplaySurfaceCreateFlagsKHR is a bitmask type for setting a mask, but is currently reserved for future use.

Possible values of VkDisplaySurfaceCreateInfoKHR::alphaMode, specifying the type of alpha blending to use on a display, are:

typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
    VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
    VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
    VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkDisplayPlaneAlphaFlagBitsKHR;

VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR specifies that the source image will be treated as opaque.
VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR specifies that a global alpha value must be specified that will be applied to all pixels in the source image.
VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR specifies that the alpha value will be determined by the alpha channel of the source image’s pixels. If the source format contains no alpha values, no blending will be applied. The source alpha values are not premultiplied into the source image’s other color channels.
VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR is equivalent to VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR, except the source alpha values are assumed to be premultiplied into the source image’s other color channels.

typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;

VkDisplayPlaneAlphaFlagsKHR is a bitmask type for setting a mask of zero or more VkDisplayPlaneAlphaFlagBitsKHR.

32.3.4. Presenting to headless surfaces

Vulkan rendering can be presented to a headless surface, where the presentation operation is a no-op producing no externally-visible result.

Note

Because there is no real presentation target, the headless presentation engine may be extended to impose an arbitrary or customisable set of restrictions and features. This makes it a useful portable test target for applications targeting a wide range of presentation engines where the actual target presentation engines might be scarce, unavailable or otherwise undesirable or inconvenient to use for general Vulkan application development.

The usual surface query mechanisms must be used to determine the actual restrictions and features of the implementation.

To create a headless VkSurfaceKHR object, call:

VkResult vkCreateHeadlessSurfaceEXT(
    VkInstance                                  instance,
    const VkHeadlessSurfaceCreateInfoEXT*       pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

instance is the instance to associate the surface with.
pCreateInfo is a pointer to a VkHeadlessSurfaceCreateInfoEXT structure containing parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface is a pointer to a VkSurfaceKHR handle in which the created surface object is returned.

Valid Usage (Implicit)

VUID-vkCreateHeadlessSurfaceEXT-instance-parameter
instance must be a valid VkInstance handle
VUID-vkCreateHeadlessSurfaceEXT-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkHeadlessSurfaceCreateInfoEXT structure
VUID-vkCreateHeadlessSurfaceEXT-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateHeadlessSurfaceEXT-pSurface-parameter
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkHeadlessSurfaceCreateInfoEXT structure is defined as:

typedef struct VkHeadlessSurfaceCreateInfoEXT {
    VkStructureType                    sType;
    const void*                        pNext;
    VkHeadlessSurfaceCreateFlagsEXT    flags;
} VkHeadlessSurfaceCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is reserved for future use.

Valid Usage (Implicit)

VUID-VkHeadlessSurfaceCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT
VUID-VkHeadlessSurfaceCreateInfoEXT-pNext-pNext
pNext must be NULL
VUID-VkHeadlessSurfaceCreateInfoEXT-flags-zerobitmask
flags must be 0

For headless surfaces, currentExtent is undefined (0xFFFFFFFF, 0xFFFFFFFF). Whatever the application sets a swapchain’s imageExtent to will be the size of the surface, after the first image is presented.

32.4. Querying for WSI Support

Not all physical devices will include WSI support. Within a physical device, not all queue families will support presentation. WSI support and compatibility can be determined in a platform-neutral manner (which determines support for presentation to a particular surface object) and additionally may be determined in platform-specific manners (which determine support for presentation on the specified physical device but do not guarantee support for presentation to a particular surface object).

To determine whether a queue family of a physical device supports presentation to a given surface, call:

VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t                                    queueFamilyIndex,
    VkSurfaceKHR                                surface,
    VkBool32*                                   pSupported);

physicalDevice is the physical device.
queueFamilyIndex is the queue family.
surface is the surface.
pSupported is a pointer to a VkBool32, which is set to VK_TRUE to indicate support, and VK_FALSE otherwise.

Valid Usage

VUID-vkGetPhysicalDeviceSurfaceSupportKHR-queueFamilyIndex-01269
queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceSurfaceSupportKHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceSurfaceSupportKHR-surface-parameter
surface must be a valid VkSurfaceKHR handle
VUID-vkGetPhysicalDeviceSurfaceSupportKHR-pSupported-parameter
pSupported must be a valid pointer to a VkBool32 value
VUID-vkGetPhysicalDeviceSurfaceSupportKHR-commonparent
Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

32.4.1. Android Platform

On Android, all physical devices and queue families must be capable of presentation with any native window. As a result there is no Android-specific query for these capabilities.

32.4.2. Wayland Platform

To determine whether a queue family of a physical device supports presentation to a Wayland compositor, call:

VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t                                    queueFamilyIndex,
    struct wl_display*                          display);

physicalDevice is the physical device.
queueFamilyIndex is the queue family index.
display is a pointer to the wl_display associated with a Wayland compositor.

This platform-specific function can be called prior to creating a surface.

Valid Usage

VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-queueFamilyIndex-01306
queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-display-parameter
display must be a valid pointer to a wl_display value

32.4.3. Win32 Platform

To determine whether a queue family of a physical device supports presentation to the Microsoft Windows desktop, call:

VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t                                    queueFamilyIndex);

physicalDevice is the physical device.
queueFamilyIndex is the queue family index.

This platform-specific function can be called prior to creating a surface.

Valid Usage

VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-queueFamilyIndex-01309
queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle

32.4.4. XCB Platform

To determine whether a queue family of a physical device supports presentation to an X11 server, using the XCB client-side library, call:

VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t                                    queueFamilyIndex,
    xcb_connection_t*                           connection,
    xcb_visualid_t                              visual_id);

physicalDevice is the physical device.
queueFamilyIndex is the queue family index.
connection is a pointer to an xcb_connection_t to the X server. visual_id is an X11 visual (xcb_visualid_t).

This platform-specific function can be called prior to creating a surface.

Valid Usage

VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-queueFamilyIndex-01312
queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-connection-parameter
connection must be a valid pointer to an xcb_connection_t value

32.4.5. Xlib Platform

To determine whether a queue family of a physical device supports presentation to an X11 server, using the Xlib client-side library, call:

VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t                                    queueFamilyIndex,
    Display*                                    dpy,
    VisualID                                    visualID);

physicalDevice is the physical device.
queueFamilyIndex is the queue family index.
dpy is a pointer to an Xlib Display connection to the server.
visualId is an X11 visual (VisualID).

This platform-specific function can be called prior to creating a surface.

Valid Usage

VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-queueFamilyIndex-01315
queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-dpy-parameter
dpy must be a valid pointer to a Display value

32.4.6. Fuchsia Platform

On Fuchsia, all physical devices and queue families must be capable of presentation with any ImagePipe. As a result there is no Fuchsia-specific query for these capabilities.

32.4.7. Google Games Platform

On Google Games Platform, all physical devices and queue families with the VK_QUEUE_GRAPHICS_BIT or VK_QUEUE_COMPUTE_BIT capabilities must be capable of presentation with any Google Games Platform stream descriptor. As a result, there is no query specific to Google Games Platform for these capabilities.

32.4.8. iOS Platform

On iOS, all physical devices and queue families must be capable of presentation with any layer. As a result there is no iOS-specific query for these capabilities.

32.4.9. macOS Platform

On macOS, all physical devices and queue families must be capable of presentation with any layer. As a result there is no macOS-specific query for these capabilities.

32.4.10. VI Platform

On VI, all physical devices and queue families must be capable of presentation with any layer. As a result there is no VI-specific query for these capabilities.

32.5. Surface Queries

The capabilities of a swapchain targeting a surface are the intersection of the capabilities of the WSI platform, the native window or display, and the physical device. The resulting capabilities can be obtained with the queries listed below in this section.

Note

In addition to the surface capabilities as obtained by surface queries below, swapchain images are also subject to ordinary image creation limits as reported by vkGetPhysicalDeviceImageFormatProperties. As an application is instructed by the appropriate Valid Usage sections, both the surface capabilities and the image creation limits have to be satisfied whenever swapchain images are created.

32.5.1. Surface Capabilities

To query the basic capabilities of a surface, needed in order to create a swapchain, call:

VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
    VkPhysicalDevice                            physicalDevice,
    VkSurfaceKHR                                surface,
    VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);

physicalDevice is the physical device that will be associated with the swapchain to be created, as described for vkCreateSwapchainKHR.
surface is the surface that will be associated with the swapchain.
pSurfaceCapabilities is a pointer to a VkSurfaceCapabilitiesKHR structure in which the capabilities are returned.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-surface-parameter
surface must be a valid VkSurfaceKHR handle
VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-pSurfaceCapabilities-parameter
pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilitiesKHR structure
VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-commonparent
Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

The VkSurfaceCapabilitiesKHR structure is defined as:

typedef struct VkSurfaceCapabilitiesKHR {
    uint32_t                         minImageCount;
    uint32_t                         maxImageCount;
    VkExtent2D                       currentExtent;
    VkExtent2D                       minImageExtent;
    VkExtent2D                       maxImageExtent;
    uint32_t                         maxImageArrayLayers;
    VkSurfaceTransformFlagsKHR       supportedTransforms;
    VkSurfaceTransformFlagBitsKHR    currentTransform;
    VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
    VkImageUsageFlags                supportedUsageFlags;
} VkSurfaceCapabilitiesKHR;

minImageCount is the minimum number of images the specified device supports for a swapchain created for the surface, and will be at least one.
maxImageCount is the maximum number of images the specified device supports for a swapchain created for the surface, and will be either 0, or greater than or equal to minImageCount. A value of 0 means that there is no limit on the number of images, though there may be limits related to the total amount of memory used by presentable images.
currentExtent is the current width and height of the surface, or the special value (0xFFFFFFFF, 0xFFFFFFFF) indicating that the surface size will be determined by the extent of a swapchain targeting the surface.
minImageExtent contains the smallest valid swapchain extent for the surface on the specified device. The width and height of the extent will each be less than or equal to the corresponding width and height of currentExtent, unless currentExtent has the special value described above.
maxImageExtent contains the largest valid swapchain extent for the surface on the specified device. The width and height of the extent will each be greater than or equal to the corresponding width and height of minImageExtent. The width and height of the extent will each be greater than or equal to the corresponding width and height of currentExtent, unless currentExtent has the special value described above.
maxImageArrayLayers is the maximum number of layers presentable images can have for a swapchain created for this device and surface, and will be at least one.
supportedTransforms is a bitmask of VkSurfaceTransformFlagBitsKHR indicating the presentation transforms supported for the surface on the specified device. At least one bit will be set.
currentTransform is VkSurfaceTransformFlagBitsKHR value indicating the surface’s current transform relative to the presentation engine’s natural orientation.
supportedCompositeAlpha is a bitmask of VkCompositeAlphaFlagBitsKHR, representing the alpha compositing modes supported by the presentation engine for the surface on the specified device, and at least one bit will be set. Opaque composition can be achieved in any alpha compositing mode by either using an image format that has no alpha component, or by ensuring that all pixels in the presentable images have an alpha value of 1.0.
supportedUsageFlags is a bitmask of VkImageUsageFlagBits representing the ways the application can use the presentable images of a swapchain created with VkPresentModeKHR set to VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR or VK_PRESENT_MODE_FIFO_RELAXED_KHR for the surface on the specified device. VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT must be included in the set but implementations may support additional usages.

Note

Supported usage flags of a presentable image when using VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR or VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR presentation mode are provided by VkSharedPresentSurfaceCapabilitiesKHR::sharedPresentSupportedUsageFlags.

Note

Formulas such as min(N, maxImageCount) are not correct, since maxImageCount may be zero.

To query the basic capabilities of a surface defined by the core or extensions, call:

VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
    VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities);

physicalDevice is the physical device that will be associated with the swapchain to be created, as described for vkCreateSwapchainKHR.
pSurfaceInfo is a pointer to a VkPhysicalDeviceSurfaceInfo2KHR structure describing the surface and other fixed parameters that would be consumed by vkCreateSwapchainKHR.
pSurfaceCapabilities is a pointer to a VkSurfaceCapabilities2KHR structure in which the capabilities are returned.

vkGetPhysicalDeviceSurfaceCapabilities2KHR behaves similarly to vkGetPhysicalDeviceSurfaceCapabilitiesKHR, with the ability to specify extended inputs via chained input structures, and to return extended information via chained output structures.

Valid Usage

VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pNext-02671
If a VkSurfaceCapabilitiesFullScreenExclusiveEXT structure is included in the pNext chain of pSurfaceCapabilities, a VkSurfaceFullScreenExclusiveWin32InfoEXT structure must be included in the pNext chain of pSurfaceInfo.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceInfo-parameter
pSurfaceInfo must be a valid pointer to a valid VkPhysicalDeviceSurfaceInfo2KHR structure
VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceCapabilities-parameter
pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilities2KHR structure

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

The VkPhysicalDeviceSurfaceInfo2KHR structure is defined as:

typedef struct VkPhysicalDeviceSurfaceInfo2KHR {
    VkStructureType    sType;
    const void*        pNext;
    VkSurfaceKHR       surface;
} VkPhysicalDeviceSurfaceInfo2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
surface is the surface that will be associated with the swapchain.

The members of VkPhysicalDeviceSurfaceInfo2KHR correspond to the arguments to vkGetPhysicalDeviceSurfaceCapabilitiesKHR, with sType and pNext added for extensibility.

Additional capabilities of a surface may be available to swapchains created with different full-screen exclusive settings - particularly if exclusive full-screen access is application controlled. These additional capabilities can be queried by adding a VkSurfaceFullScreenExclusiveInfoEXT structure to the pNext chain of this structure when used to query surface properties. Additionally, for Win32 surfaces with application controlled exclusive full-screen access, chaining a VkSurfaceFullScreenExclusiveWin32InfoEXT structure may also report additional surface capabilities. These additional capabilities only apply to swapchains created with the same parameters included in the pNext chain of VkSwapchainCreateInfoKHR.

Valid Usage

VUID-VkPhysicalDeviceSurfaceInfo2KHR-pNext-02672
If the pNext chain includes a VkSurfaceFullScreenExclusiveInfoEXT structure with its fullScreenExclusive member set to VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT, and surface was created using vkCreateWin32SurfaceKHR, a VkSurfaceFullScreenExclusiveWin32InfoEXT structure must be included in the pNext chain

Valid Usage (Implicit)

VUID-VkPhysicalDeviceSurfaceInfo2KHR-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR
VUID-VkPhysicalDeviceSurfaceInfo2KHR-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkSurfaceFullScreenExclusiveInfoEXT or VkSurfaceFullScreenExclusiveWin32InfoEXT
VUID-VkPhysicalDeviceSurfaceInfo2KHR-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter
surface must be a valid VkSurfaceKHR handle

If the pNext chain of VkSwapchainCreateInfoKHR includes a VkSurfaceFullScreenExclusiveInfoEXT structure, then that structure specifies the application’s preferred full-screen transition behavior.

The VkSurfaceFullScreenExclusiveInfoEXT structure is defined as:

typedef struct VkSurfaceFullScreenExclusiveInfoEXT {
    VkStructureType             sType;
    void*                       pNext;
    VkFullScreenExclusiveEXT    fullScreenExclusive;
} VkSurfaceFullScreenExclusiveInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
fullScreenExclusive is a VkFullScreenExclusiveEXT value specifying the preferred full-screen transition behavior.

If this structure is not present, fullScreenExclusive is considered to be VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT.

Valid Usage (Implicit)

VUID-VkSurfaceFullScreenExclusiveInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT
VUID-VkSurfaceFullScreenExclusiveInfoEXT-fullScreenExclusive-parameter
fullScreenExclusive must be a valid VkFullScreenExclusiveEXT value

Possible values of VkSurfaceFullScreenExclusiveInfoEXT::fullScreenExclusive are:

typedef enum VkFullScreenExclusiveEXT {
    VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0,
    VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1,
    VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2,
    VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3,
    VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF
} VkFullScreenExclusiveEXT;

VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT indicates the implementation should determine the appropriate full-screen method by whatever means it deems appropriate.
VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT indicates the implementation may use full-screen exclusive mechanisms when available. Such mechanisms may result in better performance and/or the availability of different presentation capabilities, but may require a more disruptive transition during swapchain initialization, first presentation and/or destruction.
VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT indicates the implementation should avoid using full-screen mechanisms which rely on disruptive transitions.
VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT indicates the application will manage full-screen exclusive mode by using the vkAcquireFullScreenExclusiveModeEXT and vkReleaseFullScreenExclusiveModeEXT commands.

The VkSurfaceFullScreenExclusiveWin32InfoEXT structure is defined as:

typedef struct VkSurfaceFullScreenExclusiveWin32InfoEXT {
    VkStructureType    sType;
    const void*        pNext;
    HMONITOR           hmonitor;
} VkSurfaceFullScreenExclusiveWin32InfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
hmonitor is the Win32 HMONITOR handle identifying the display to create the surface with.

Note

If hmonitor is invalidated (e.g. the monitor is unplugged) during the lifetime of a swapchain created with this structure, operations on that swapchain will return VK_ERROR_OUT_OF_DATE_KHR.

Note

It’s the responsibility of the application to change the display settings of the targeted Win32 display using the appropriate platform APIs. Such changes may alter the surface capabilities reported for the created surface.

Valid Usage

VUID-VkSurfaceFullScreenExclusiveWin32InfoEXT-hmonitor-02673
hmonitor must be a valid HMONITOR

Valid Usage (Implicit)

VUID-VkSurfaceFullScreenExclusiveWin32InfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT

The VkSurfaceCapabilities2KHR structure is defined as:

typedef struct VkSurfaceCapabilities2KHR {
    VkStructureType             sType;
    void*                       pNext;
    VkSurfaceCapabilitiesKHR    surfaceCapabilities;
} VkSurfaceCapabilities2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
surfaceCapabilities is a VkSurfaceCapabilitiesKHR structure describing the capabilities of the specified surface.

Valid Usage (Implicit)

VUID-VkSurfaceCapabilities2KHR-sType-sType
sType must be VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR
VUID-VkSurfaceCapabilities2KHR-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDisplayNativeHdrSurfaceCapabilitiesAMD, VkSharedPresentSurfaceCapabilitiesKHR, VkSurfaceCapabilitiesFullScreenExclusiveEXT, or VkSurfaceProtectedCapabilitiesKHR
VUID-VkSurfaceCapabilities2KHR-sType-unique
The sType value of each struct in the pNext chain must be unique

An application queries if a protected VkSurfaceKHR is displayable on a specific windowing system using VkSurfaceProtectedCapabilitiesKHR, which can be passed in pNext parameter of VkSurfaceCapabilities2KHR.

The VkSurfaceProtectedCapabilitiesKHR structure is defined as:

typedef struct VkSurfaceProtectedCapabilitiesKHR {
    VkStructureType    sType;
    const void*        pNext;
    VkBool32           supportsProtected;
} VkSurfaceProtectedCapabilitiesKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
supportsProtected specifies whether a protected swapchain created from VkPhysicalDeviceSurfaceInfo2KHR::surface for a particular windowing system can be displayed on screen or not. If supportsProtected is VK_TRUE, then creation of swapchains with the VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR flag set must be supported for surface.

Valid Usage (Implicit)

VUID-VkSurfaceProtectedCapabilitiesKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR

The VkSharedPresentSurfaceCapabilitiesKHR structure is defined as:

typedef struct VkSharedPresentSurfaceCapabilitiesKHR {
    VkStructureType      sType;
    void*                pNext;
    VkImageUsageFlags    sharedPresentSupportedUsageFlags;
} VkSharedPresentSurfaceCapabilitiesKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
sharedPresentSupportedUsageFlags is a bitmask of VkImageUsageFlagBits representing the ways the application can use the shared presentable image from a swapchain created with VkPresentModeKHR set to VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR or VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR for the surface on the specified device. VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT must be included in the set but implementations may support additional usages.

Valid Usage (Implicit)

VUID-VkSharedPresentSurfaceCapabilitiesKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR

The VkDisplayNativeHdrSurfaceCapabilitiesAMD structure is defined as:

typedef struct VkDisplayNativeHdrSurfaceCapabilitiesAMD {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           localDimmingSupport;
} VkDisplayNativeHdrSurfaceCapabilitiesAMD;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
localDimmingSupport specifies whether the surface supports local dimming. If this is VK_TRUE, VkSwapchainDisplayNativeHdrCreateInfoAMD can be used to explicitly enable or disable local dimming for the surface. Local dimming may also be overriden by vkSetLocalDimmingAMD during the lifetime of the swapchain.

Valid Usage (Implicit)

VUID-VkDisplayNativeHdrSurfaceCapabilitiesAMD-sType-sType
sType must be VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD

The VkSurfaceCapabilitiesFullScreenExclusiveEXT structure is defined as:

typedef struct VkSurfaceCapabilitiesFullScreenExclusiveEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           fullScreenExclusiveSupported;
} VkSurfaceCapabilitiesFullScreenExclusiveEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
fullScreenExclusiveControlSupported is a boolean describing whether the surface is able to make use of exclusive full-screen access.

This structure can be included in the pNext chain of VkSurfaceCapabilities2KHR to determine support for exclusive full-screen access. If fullScreenExclusiveSupported is VK_FALSE, it indicates that exclusive full-screen access is not obtainable for this surface.

Applications must not attempt to create swapchains with VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT set if fullScreenExclusiveSupported is VK_FALSE.

Valid Usage (Implicit)

VUID-VkSurfaceCapabilitiesFullScreenExclusiveEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT

To query the basic capabilities of a surface, needed in order to create a swapchain, call:

VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(
    VkPhysicalDevice                            physicalDevice,
    VkSurfaceKHR                                surface,
    VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities);

physicalDevice is the physical device that will be associated with the swapchain to be created, as described for vkCreateSwapchainKHR.
surface is the surface that will be associated with the swapchain.
pSurfaceCapabilities is a pointer to a VkSurfaceCapabilities2EXT structure in which the capabilities are returned.

vkGetPhysicalDeviceSurfaceCapabilities2EXT behaves similarly to vkGetPhysicalDeviceSurfaceCapabilitiesKHR, with the ability to return extended information by adding extension structures to the pNext chain of its pSurfaceCapabilities parameter.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-surface-parameter
surface must be a valid VkSurfaceKHR handle
VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-pSurfaceCapabilities-parameter
pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilities2EXT structure
VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-commonparent
Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

The VkSurfaceCapabilities2EXT structure is defined as:

typedef struct VkSurfaceCapabilities2EXT {
    VkStructureType                  sType;
    void*                            pNext;
    uint32_t                         minImageCount;
    uint32_t                         maxImageCount;
    VkExtent2D                       currentExtent;
    VkExtent2D                       minImageExtent;
    VkExtent2D                       maxImageExtent;
    uint32_t                         maxImageArrayLayers;
    VkSurfaceTransformFlagsKHR       supportedTransforms;
    VkSurfaceTransformFlagBitsKHR    currentTransform;
    VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
    VkImageUsageFlags                supportedUsageFlags;
    VkSurfaceCounterFlagsEXT         supportedSurfaceCounters;
} VkSurfaceCapabilities2EXT;

All members of VkSurfaceCapabilities2EXT are identical to the corresponding members of VkSurfaceCapabilitiesKHR where one exists. The remaining members are:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
supportedSurfaceCounters is a bitmask of VkSurfaceCounterFlagBitsEXT indicating the supported surface counter types.

Valid Usage

VUID-VkSurfaceCapabilities2EXT-supportedSurfaceCounters-01246
supportedSurfaceCounters must not include VK_SURFACE_COUNTER_VBLANK_EXT unless the surface queried is a display surface.

Valid Usage (Implicit)

VUID-VkSurfaceCapabilities2EXT-sType-sType
sType must be VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT
VUID-VkSurfaceCapabilities2EXT-pNext-pNext
pNext must be NULL

Bits which can be set in VkSurfaceCapabilities2EXT::supportedSurfaceCounters, indicating supported surface counter types, are:

typedef enum VkSurfaceCounterFlagBitsEXT {
    VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001,
    VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
} VkSurfaceCounterFlagBitsEXT;

VK_SURFACE_COUNTER_VBLANK_EXT specifies a counter incrementing once every time a vertical blanking period occurs on the display associated with the surface.

typedef VkFlags VkSurfaceCounterFlagsEXT;

VkSurfaceCounterFlagsEXT is a bitmask type for setting a mask of zero or more VkSurfaceCounterFlagBitsEXT.

Bits which may be set in VkSurfaceCapabilitiesKHR::supportedTransforms indicating the presentation transforms supported for the surface on the specified device, and possible values of VkSurfaceCapabilitiesKHR::currentTransform is indicating the surface’s current transform relative to the presentation engine’s natural orientation, are:

typedef enum VkSurfaceTransformFlagBitsKHR {
    VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001,
    VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
    VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
    VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,
    VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
    VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkSurfaceTransformFlagBitsKHR;

VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR specifies that image content is presented without being transformed.
VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR specifies that image content is rotated 90 degrees clockwise.
VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR specifies that image content is rotated 180 degrees clockwise.
VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR specifies that image content is rotated 270 degrees clockwise.
VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR specifies that image content is mirrored horizontally.
VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR specifies that image content is mirrored horizontally, then rotated 90 degrees clockwise.
VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR specifies that image content is mirrored horizontally, then rotated 180 degrees clockwise.
VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR specifies that image content is mirrored horizontally, then rotated 270 degrees clockwise.
VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR specifies that the presentation transform is not specified, and is instead determined by platform-specific considerations and mechanisms outside Vulkan.

typedef VkFlags VkSurfaceTransformFlagsKHR;

VkSurfaceTransformFlagsKHR is a bitmask type for setting a mask of zero or more VkSurfaceTransformFlagBitsKHR.

The supportedCompositeAlpha member is of type VkCompositeAlphaFlagBitsKHR, which contains the following values:

typedef enum VkCompositeAlphaFlagBitsKHR {
    VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
    VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
    VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
    VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
    VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkCompositeAlphaFlagBitsKHR;

These values are described as follows:

VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR: The alpha channel, if it exists, of the images is ignored in the compositing process. Instead, the image is treated as if it has a constant alpha of 1.0.
VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR: The alpha channel, if it exists, of the images is respected in the compositing process. The non-alpha channels of the image are expected to already be multiplied by the alpha channel by the application.
VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR: The alpha channel, if it exists, of the images is respected in the compositing process. The non-alpha channels of the image are not expected to already be multiplied by the alpha channel by the application; instead, the compositor will multiply the non-alpha channels of the image by the alpha channel during compositing.
VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR: The way in which the presentation engine treats the alpha channel in the images is unknown to the Vulkan API. Instead, the application is responsible for setting the composite alpha blending mode using native window system commands. If the application does not set the blending mode using native window system commands, then a platform-specific default will be used.

typedef VkFlags VkCompositeAlphaFlagsKHR;

VkCompositeAlphaFlagsKHR is a bitmask type for setting a mask of zero or more VkCompositeAlphaFlagBitsKHR.

32.5.2. Surface Format Support

To query the supported swapchain format-color space pairs for a surface, call:

VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(
    VkPhysicalDevice                            physicalDevice,
    VkSurfaceKHR                                surface,
    uint32_t*                                   pSurfaceFormatCount,
    VkSurfaceFormatKHR*                         pSurfaceFormats);

physicalDevice is the physical device that will be associated with the swapchain to be created, as described for vkCreateSwapchainKHR.
surface is the surface that will be associated with the swapchain.
pSurfaceFormatCount is a pointer to an integer related to the number of format pairs available or queried, as described below.
pSurfaceFormats is either NULL or a pointer to an array of VkSurfaceFormatKHR structures.

If pSurfaceFormats is NULL, then the number of format pairs supported for the given surface is returned in pSurfaceFormatCount. Otherwise, pSurfaceFormatCount must point to a variable set by the user to the number of elements in the pSurfaceFormats array, and on return the variable is overwritten with the number of structures actually written to pSurfaceFormats. If the value of pSurfaceFormatCount is less than the number of format pairs supported, at most pSurfaceFormatCount structures will be written. If pSurfaceFormatCount is smaller than the number of format pairs supported for the given surface, VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned.

The number of format pairs supported must be greater than or equal to 1. pSurfaceFormats must not contain an entry whose value for format is VK_FORMAT_UNDEFINED.

If pSurfaceFormats includes an entry whose value for colorSpace is VK_COLOR_SPACE_SRGB_NONLINEAR_KHR and whose value for format is a UNORM (or SRGB) format and the corresponding SRGB (or UNORM) format is a color renderable format for VK_IMAGE_TILING_OPTIMAL, then pSurfaceFormats must also contain an entry with the same value for colorSpace and format equal to the corresponding SRGB (or UNORM) format.

Valid Usage

VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-02739
surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-parameter
surface must be a valid VkSurfaceKHR handle
VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormatCount-parameter
pSurfaceFormatCount must be a valid pointer to a uint32_t value
VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormats-parameter
If the value referenced by pSurfaceFormatCount is not 0, and pSurfaceFormats is not NULL, pSurfaceFormats must be a valid pointer to an array of pSurfaceFormatCount VkSurfaceFormatKHR structures
VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-commonparent
Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

The VkSurfaceFormatKHR structure is defined as:

typedef struct VkSurfaceFormatKHR {
    VkFormat           format;
    VkColorSpaceKHR    colorSpace;
} VkSurfaceFormatKHR;

format is a VkFormat that is compatible with the specified surface.
colorSpace is a presentation VkColorSpaceKHR that is compatible with the surface.

To query the supported swapchain format tuples for a surface, call:

VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
    uint32_t*                                   pSurfaceFormatCount,
    VkSurfaceFormat2KHR*                        pSurfaceFormats);

physicalDevice is the physical device that will be associated with the swapchain to be created, as described for vkCreateSwapchainKHR.
pSurfaceInfo is a pointer to a VkPhysicalDeviceSurfaceInfo2KHR structure describing the surface and other fixed parameters that would be consumed by vkCreateSwapchainKHR.
pSurfaceFormatCount is a pointer to an integer related to the number of format tuples available or queried, as described below.
pSurfaceFormats is either NULL or a pointer to an array of VkSurfaceFormat2KHR structures.

vkGetPhysicalDeviceSurfaceFormats2KHR behaves similarly to vkGetPhysicalDeviceSurfaceFormatsKHR, with the ability to be extended via pNext chains.

If pSurfaceFormats is NULL, then the number of format tuples supported for the given surface is returned in pSurfaceFormatCount. Otherwise, pSurfaceFormatCount must point to a variable set by the user to the number of elements in the pSurfaceFormats array, and on return the variable is overwritten with the number of structures actually written to pSurfaceFormats. If the value of pSurfaceFormatCount is less than the number of format tuples supported, at most pSurfaceFormatCount structures will be written. If pSurfaceFormatCount is smaller than the number of format tuples supported for the surface parameters described in pSurfaceInfo, VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned.

Valid Usage

VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-02740
pSurfaceInfo->surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-parameter
pSurfaceInfo must be a valid pointer to a valid VkPhysicalDeviceSurfaceInfo2KHR structure
VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceFormatCount-parameter
pSurfaceFormatCount must be a valid pointer to a uint32_t value
VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceFormats-parameter
If the value referenced by pSurfaceFormatCount is not 0, and pSurfaceFormats is not NULL, pSurfaceFormats must be a valid pointer to an array of pSurfaceFormatCount VkSurfaceFormat2KHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

The VkSurfaceFormat2KHR structure is defined as:

typedef struct VkSurfaceFormat2KHR {
    VkStructureType       sType;
    void*                 pNext;
    VkSurfaceFormatKHR    surfaceFormat;
} VkSurfaceFormat2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
surfaceFormat is a VkSurfaceFormatKHR structure describing a format-color space pair that is compatible with the specified surface.

Valid Usage (Implicit)

VUID-VkSurfaceFormat2KHR-sType-sType
sType must be VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR
VUID-VkSurfaceFormat2KHR-pNext-pNext
pNext must be NULL

While the format of a presentable image refers to the encoding of each pixel, the colorSpace determines how the presentation engine interprets the pixel values. A color space in this document refers to a specific color space (defined by the chromaticities of its primaries and a white point in CIE Lab), and a transfer function that is applied before storing or transmitting color data in the given color space.

Possible values of VkSurfaceFormatKHR::colorSpace, specifying supported color spaces of a presentation engine, are:

typedef enum VkColorSpaceKHR {
    VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0,
    VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001,
    VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002,
    VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003,
    VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004,
    VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005,
    VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006,
    VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007,
    VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008,
    VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009,
    VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010,
    VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011,
    VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012,
    VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013,
    VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014,
    VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000,
    VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
    VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT,
    VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF
} VkColorSpaceKHR;

VK_COLOR_SPACE_SRGB_NONLINEAR_KHR specifies support for the sRGB color space.
VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT specifies support for the Display-P3 color space to be displayed using an sRGB-like EOTF (defined below).
VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT specifies support for the extended sRGB color space to be displayed using a linear EOTF.
VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT specifies support for the extended sRGB color space to be displayed using an sRGB EOTF.
VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT specifies support for the Display-P3 color space to be displayed using a linear EOTF.
VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT specifies support for the DCI-P3 color space to be displayed using the DCI-P3 EOTF. Note that values in such an image are interpreted as XYZ encoded color data by the presentation engine.
VK_COLOR_SPACE_BT709_LINEAR_EXT specifies support for the BT709 color space to be displayed using a linear EOTF.
VK_COLOR_SPACE_BT709_NONLINEAR_EXT specifies support for the BT709 color space to be displayed using the SMPTE 170M EOTF.
VK_COLOR_SPACE_BT2020_LINEAR_EXT specifies support for the BT2020 color space to be displayed using a linear EOTF.
VK_COLOR_SPACE_HDR10_ST2084_EXT specifies support for the HDR10 (BT2020 color) space to be displayed using the SMPTE ST2084 Perceptual Quantizer (PQ) EOTF.
VK_COLOR_SPACE_DOLBYVISION_EXT specifies support for the Dolby Vision (BT2020 color space), proprietary encoding, to be displayed using the SMPTE ST2084 EOTF.
VK_COLOR_SPACE_HDR10_HLG_EXT specifies support for the HDR10 (BT2020 color space) to be displayed using the Hybrid Log Gamma (HLG) EOTF.
VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT specifies support for the AdobeRGB color space to be displayed using a linear EOTF.
VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT specifies support for the AdobeRGB color space to be displayed using the Gamma 2.2 EOTF.
VK_COLOR_SPACE_PASS_THROUGH_EXT specifies that color components are used “as is”. This is intended to allow applications to supply data for color spaces not described here.
VK_COLOR_SPACE_DISPLAY_NATIVE_AMD specifies support for the display’s native color space. This matches the color space expectations of AMD’s FreeSync2 standard, for displays supporting it.

Note

In the initial release of the VK_KHR_surface and VK_KHR_swapchain extensions, the token VK_COLORSPACE_SRGB_NONLINEAR_KHR was used. Starting in the 2016-05-13 updates to the extension branches, matching release 1.0.13 of the core API specification, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR is used instead for consistency with Vulkan naming rules. The older enum is still available for backwards compatibility.

Note

In older versions of this extension VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT was misnamed VK_COLOR_SPACE_DCI_P3_LINEAR_EXT. This has been updated to indicate that it uses RGB color encoding, not XYZ. The old name is deprecated but is maintained for backwards compatibility.

The color components of non-linear color space swap chain images must have had the appropriate transfer function applied. The color space selected for the swap chain image will not affect the processing of data written into the image by the implementation. Vulkan requires that all implementations support the sRGB transfer function by use of an SRGB pixel format. Other transfer functions, such as SMPTE 170M or SMPTE2084, can be performed by the application shader. This extension defines enums for VkColorSpaceKHR that correspond to the following color spaces:

Table 42. Color Spaces and Attributes
Name	Red Primary	Green Primary	Blue Primary	White-point	Transfer function
DCI-P3	1.000, 0.000	0.000, 1.000	0.000, 0.000	0.3333, 0.3333	DCI P3
Display-P3	0.680, 0.320	0.265, 0.690	0.150, 0.060	0.3127, 0.3290 (D65)	Display-P3
BT709	0.640, 0.330	0.300, 0.600	0.150, 0.060	0.3127, 0.3290 (D65)	ITU (SMPTE 170M)
sRGB	0.640, 0.330	0.300, 0.600	0.150, 0.060	0.3127, 0.3290 (D65)	sRGB
extended sRGB	0.640, 0.330	0.300, 0.600	0.150, 0.060	0.3127, 0.3290 (D65)	extended sRGB
HDR10_ST2084	0.708, 0.292	0.170, 0.797	0.131, 0.046	0.3127, 0.3290 (D65)	ST2084 PQ
DOLBYVISION	0.708, 0.292	0.170, 0.797	0.131, 0.046	0.3127, 0.3290 (D65)	ST2084 PQ
HDR10_HLG	0.708, 0.292	0.170, 0.797	0.131, 0.046	0.3127, 0.3290 (D65)	HLG
AdobeRGB	0.640, 0.330	0.210, 0.710	0.150, 0.060	0.3127, 0.3290 (D65)	AdobeRGB

The transfer functions are described in the “Transfer Functions” chapter of the Khronos Data Format Specification.

Except Display-P3 OETF, which is:

\[\begin{aligned} E & = \begin{cases} 1.055 \times L^{1 \over 2.4} - 0.055 & \text{for}\ 0.0030186 \leq L \leq 1 \\ 12.92 \times L & \text{for}\ 0 \leq L < 0.0030186 \end{cases} \end{aligned}\]

where L is the linear value of a color channel and E is the encoded value (as stored in the image in memory).

Note

For most uses, the sRGB OETF is equivalent.

32.5.3. Surface Presentation Mode Support

To query the supported presentation modes for a surface, call:

VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
    VkPhysicalDevice                            physicalDevice,
    VkSurfaceKHR                                surface,
    uint32_t*                                   pPresentModeCount,
    VkPresentModeKHR*                           pPresentModes);

physicalDevice is the physical device that will be associated with the swapchain to be created, as described for vkCreateSwapchainKHR.
surface is the surface that will be associated with the swapchain.
pPresentModeCount is a pointer to an integer related to the number of presentation modes available or queried, as described below.
pPresentModes is either NULL or a pointer to an array of VkPresentModeKHR values, indicating the supported presentation modes.

If pPresentModes is NULL, then the number of presentation modes supported for the given surface is returned in pPresentModeCount. Otherwise, pPresentModeCount must point to a variable set by the user to the number of elements in the pPresentModes array, and on return the variable is overwritten with the number of values actually written to pPresentModes. If the value of pPresentModeCount is less than the number of presentation modes supported, at most pPresentModeCount values will be written. If pPresentModeCount is smaller than the number of presentation modes supported for the given surface, VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-parameter
surface must be a valid VkSurfaceKHR handle
VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModeCount-parameter
pPresentModeCount must be a valid pointer to a uint32_t value
VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModes-parameter
If the value referenced by pPresentModeCount is not 0, and pPresentModes is not NULL, pPresentModes must be a valid pointer to an array of pPresentModeCount VkPresentModeKHR values
VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-commonparent
Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

Alternatively, to query the supported presentation modes for a surface combined with select other fixed swapchain creation parameters, call:

VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
    uint32_t*                                   pPresentModeCount,
    VkPresentModeKHR*                           pPresentModes);

physicalDevice is the physical device that will be associated with the swapchain to be created, as described for vkCreateSwapchainKHR.
pSurfaceInfo is a pointer to a VkPhysicalDeviceSurfaceInfo2KHR structure describing the surface and other fixed parameters that would be consumed by vkCreateSwapchainKHR.
pPresentModeCount is a pointer to an integer related to the number of presentation modes available or queried, as described below.
pPresentModes is either NULL or a pointer to an array of VkPresentModeKHR values, indicating the supported presentation modes.

vkGetPhysicalDeviceSurfacePresentModes2EXT behaves similarly to vkGetPhysicalDeviceSurfacePresentModesKHR, with the ability to specify extended inputs via chained input structures.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-pSurfaceInfo-parameter
pSurfaceInfo must be a valid pointer to a valid VkPhysicalDeviceSurfaceInfo2KHR structure
VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-pPresentModeCount-parameter
pPresentModeCount must be a valid pointer to a uint32_t value
VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-pPresentModes-parameter
If the value referenced by pPresentModeCount is not 0, and pPresentModes is not NULL, pPresentModes must be a valid pointer to an array of pPresentModeCount VkPresentModeKHR values

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

Possible values of elements of the vkGetPhysicalDeviceSurfacePresentModesKHR::pPresentModes array, indicating the supported presentation modes for a surface, are:

typedef enum VkPresentModeKHR {
    VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
    VK_PRESENT_MODE_MAILBOX_KHR = 1,
    VK_PRESENT_MODE_FIFO_KHR = 2,
    VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
    VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000,
    VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001,
    VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
} VkPresentModeKHR;

VK_PRESENT_MODE_IMMEDIATE_KHR specifies that the presentation engine does not wait for a vertical blanking period to update the current image, meaning this mode may result in visible tearing. No internal queuing of presentation requests is needed, as the requests are applied immediately.
VK_PRESENT_MODE_MAILBOX_KHR specifies that the presentation engine waits for the next vertical blanking period to update the current image. Tearing cannot be observed. An internal single-entry queue is used to hold pending presentation requests. If the queue is full when a new presentation request is received, the new request replaces the existing entry, and any images associated with the prior entry become available for re-use by the application. One request is removed from the queue and processed during each vertical blanking period in which the queue is non-empty.
VK_PRESENT_MODE_FIFO_KHR specifies that the presentation engine waits for the next vertical blanking period to update the current image. Tearing cannot be observed. An internal queue is used to hold pending presentation requests. New requests are appended to the end of the queue, and one request is removed from the beginning of the queue and processed during each vertical blanking period in which the queue is non-empty. This is the only value of presentMode that is required to be supported.
VK_PRESENT_MODE_FIFO_RELAXED_KHR specifies that the presentation engine generally waits for the next vertical blanking period to update the current image. If a vertical blanking period has already passed since the last update of the current image then the presentation engine does not wait for another vertical blanking period for the update, meaning this mode may result in visible tearing in this case. This mode is useful for reducing visual stutter with an application that will mostly present a new image before the next vertical blanking period, but may occasionally be late, and present a new image just after the next vertical blanking period. An internal queue is used to hold pending presentation requests. New requests are appended to the end of the queue, and one request is removed from the beginning of the queue and processed during or after each vertical blanking period in which the queue is non-empty.
VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR specifies that the presentation engine and application have concurrent access to a single image, which is referred to as a shared presentable image. The presentation engine is only required to update the current image after a new presentation request is received. Therefore the application must make a presentation request whenever an update is required. However, the presentation engine may update the current image at any point, meaning this mode may result in visible tearing.
VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR specifies that the presentation engine and application have concurrent access to a single image, which is referred to as a shared presentable image. The presentation engine periodically updates the current image on its regular refresh cycle. The application is only required to make one initial presentation request, after which the presentation engine must update the current image without any need for further presentation requests. The application can indicate the image contents have been updated by making a presentation request, but this does not guarantee the timing of when it will be updated. This mode may result in visible tearing if rendering to the image is not timed correctly.

The supported VkImageUsageFlagBits of the presentable images of a swapchain created for a surface may differ depending on the presentation mode, and can be determined as per the table below:

Table 43. Presentable image usage queries
Presentation mode	Image usage flags
`VK_PRESENT_MODE_IMMEDIATE_KHR`	VkSurfaceCapabilitiesKHR::`supportedUsageFlags`
`VK_PRESENT_MODE_MAILBOX_KHR`	VkSurfaceCapabilitiesKHR::`supportedUsageFlags`
`VK_PRESENT_MODE_FIFO_KHR`	VkSurfaceCapabilitiesKHR::`supportedUsageFlags`
`VK_PRESENT_MODE_FIFO_RELAXED_KHR`	VkSurfaceCapabilitiesKHR::`supportedUsageFlags`
`VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR`	VkSharedPresentSurfaceCapabilitiesKHR::`sharedPresentSupportedUsageFlags`
`VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR`	VkSharedPresentSurfaceCapabilitiesKHR::`sharedPresentSupportedUsageFlags`

Note

For reference, the mode indicated by VK_PRESENT_MODE_FIFO_KHR is equivalent to the behavior of {wgl|glX|egl}SwapBuffers with a swap interval of 1, while the mode indicated by VK_PRESENT_MODE_FIFO_RELAXED_KHR is equivalent to the behavior of {wgl|glX}SwapBuffers with a swap interval of -1 (from the {WGL|GLX}_EXT_swap_control_tear extensions).

32.6. Full Screen Exclusive Control

Swapchains created with fullScreenExclusive set to VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT must acquire and release exclusive full-screen access explicitly, using the following commands.

To acquire exclusive full-screen access for a swapchain, call:

VkResult vkAcquireFullScreenExclusiveModeEXT(
    VkDevice                                    device,
    VkSwapchainKHR                              swapchain);

device is the device associated with swapchain.
swapchain is the swapchain to acquire exclusive full-screen access for.

Valid Usage

VUID-vkAcquireFullScreenExclusiveModeEXT-swapchain-02674
swapchain must not be in the retired state
VUID-vkAcquireFullScreenExclusiveModeEXT-swapchain-02675
swapchain must be a swapchain created with a VkSurfaceFullScreenExclusiveInfoEXT structure, with fullScreenExclusive set to VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT
VUID-vkAcquireFullScreenExclusiveModeEXT-swapchain-02676
swapchain must not currently have exclusive full-screen access

A return value of VK_SUCCESS indicates that the swapchain successfully acquired exclusive full-screen access. The swapchain will retain this exclusivity until either the application releases exclusive full-screen access with vkReleaseFullScreenExclusiveModeEXT, destroys the swapchain, or if any of the swapchain commands return VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT indicating that the mode was lost because of platform-specific changes.

If the swapchain was unable to acquire exclusive full-screen access to the display then VK_ERROR_INITIALIZATION_FAILED is returned. An application can attempt to acquire exclusive full-screen access again for the same swapchain even if this command fails, or if VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT has been returned by a swapchain command.

Valid Usage (Implicit)

VUID-vkAcquireFullScreenExclusiveModeEXT-device-parameter
device must be a valid VkDevice handle
VUID-vkAcquireFullScreenExclusiveModeEXT-swapchain-parameter
swapchain must be a valid VkSwapchainKHR handle
VUID-vkAcquireFullScreenExclusiveModeEXT-commonparent
Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INITIALIZATION_FAILED
VK_ERROR_SURFACE_LOST_KHR

To release exclusive full-screen access from a swapchain, call:

VkResult vkReleaseFullScreenExclusiveModeEXT(
    VkDevice                                    device,
    VkSwapchainKHR                              swapchain);

device is the device associated with swapchain.
swapchain is the swapchain to release exclusive full-screen access from.

Note

Applications will not be able to present to swapchain after this call until exclusive full-screen access is reacquired. This is usually useful to handle when an application is minimised or otherwise intends to stop presenting for a time.

Valid Usage

VUID-vkReleaseFullScreenExclusiveModeEXT-swapchain-02677
swapchain must not be in the retired state
VUID-vkReleaseFullScreenExclusiveModeEXT-swapchain-02678
swapchain must be a swapchain created with a VkSurfaceFullScreenExclusiveInfoEXT structure, with fullScreenExclusive set to VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT

32.7. Device Group Queries

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

To query these capabilities, call:

VkResult vkGetDeviceGroupPresentCapabilitiesKHR(
    VkDevice                                    device,
    VkDeviceGroupPresentCapabilitiesKHR*        pDeviceGroupPresentCapabilities);

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

Valid Usage (Implicit)

VUID-vkGetDeviceGroupPresentCapabilitiesKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkGetDeviceGroupPresentCapabilitiesKHR-pDeviceGroupPresentCapabilities-parameter
pDeviceGroupPresentCapabilities must be a valid pointer to a VkDeviceGroupPresentCapabilitiesKHR structure

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkDeviceGroupPresentCapabilitiesKHR structure is defined as:

typedef struct VkDeviceGroupPresentCapabilitiesKHR {
    VkStructureType                     sType;
    const void*                         pNext;
    uint32_t                            presentMask[VK_MAX_DEVICE_GROUP_SIZE];
    VkDeviceGroupPresentModeFlagsKHR    modes;
} VkDeviceGroupPresentCapabilitiesKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
presentMask is an array of VK_MAX_DEVICE_GROUP_SIZE uint32_t masks, where the mask at element i is non-zero if physical device i has a presentation engine, and where bit j is set in element i if physical device i can present swapchain images from physical device j. If element i is non-zero, then bit i must be set.
modes is a bitmask of VkDeviceGroupPresentModeFlagBitsKHR indicating which device group presentation modes are supported.

modes always has VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR set.

The present mode flags are also used when presenting an image, in VkDeviceGroupPresentInfoKHR::mode.

If a device group only includes a single physical device, then modes must equal VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR.

Valid Usage (Implicit)

VUID-VkDeviceGroupPresentCapabilitiesKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR
VUID-VkDeviceGroupPresentCapabilitiesKHR-pNext-pNext
pNext must be NULL

Bits which may be set in VkDeviceGroupPresentCapabilitiesKHR::modes to indicate which device group presentation modes are supported are:

typedef enum VkDeviceGroupPresentModeFlagBitsKHR {
    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001,
    VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002,
    VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004,
    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008,
    VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkDeviceGroupPresentModeFlagBitsKHR;

VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR specifies that any physical device with a presentation engine can present its own swapchain images.
VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR specifies that any physical device with a presentation engine can present swapchain images from any physical device in its presentMask.
VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR specifies that any physical device with a presentation engine can present the sum of swapchain images from any physical devices in its presentMask.
VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR specifies that multiple physical devices with a presentation engine can each present their own swapchain images.

typedef VkFlags VkDeviceGroupPresentModeFlagsKHR;

VkDeviceGroupPresentModeFlagsKHR is a bitmask type for setting a mask of zero or more VkDeviceGroupPresentModeFlagBitsKHR.

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

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

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

device is the logical device.
surface is the surface.
pModes is a pointer to a VkDeviceGroupPresentModeFlagsKHR in which the supported device group present modes for the surface are returned.

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

Valid Usage (Implicit)

VUID-vkGetDeviceGroupSurfacePresentModesKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkGetDeviceGroupSurfacePresentModesKHR-surface-parameter
surface must be a valid VkSurfaceKHR handle
VUID-vkGetDeviceGroupSurfacePresentModesKHR-pModes-parameter
pModes must be a valid pointer to a VkDeviceGroupPresentModeFlagsKHR value
VUID-vkGetDeviceGroupSurfacePresentModesKHR-commonparent
Both of device, and surface must have been created, allocated, or retrieved from the same VkInstance

Host Synchronization

Host access to surface must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

Alternatively, to query the supported device group presentation modes for a surface combined with select other fixed swapchain creation parameters, call:

VkResult vkGetDeviceGroupSurfacePresentModes2EXT(
    VkDevice                                    device,
    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
    VkDeviceGroupPresentModeFlagsKHR*           pModes);

device is the logical device.
pSurfaceInfo is a pointer to a VkPhysicalDeviceSurfaceInfo2KHR structure describing the surface and other fixed parameters that would be consumed by vkCreateSwapchainKHR.
pModes is a pointer to a VkDeviceGroupPresentModeFlagsKHR in which the supported device group present modes for the surface are returned.

vkGetDeviceGroupSurfacePresentModes2EXT behaves similarly to vkGetDeviceGroupSurfacePresentModesKHR, with the ability to specify extended inputs via chained input structures.

Valid Usage (Implicit)

VUID-vkGetDeviceGroupSurfacePresentModes2EXT-device-parameter
device must be a valid VkDevice handle
VUID-vkGetDeviceGroupSurfacePresentModes2EXT-pSurfaceInfo-parameter
pSurfaceInfo must be a valid pointer to a valid VkPhysicalDeviceSurfaceInfo2KHR structure
VUID-vkGetDeviceGroupSurfacePresentModes2EXT-pModes-parameter
pModes must be a valid pointer to a VkDeviceGroupPresentModeFlagsKHR value

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

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

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

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

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

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

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

The rectangles returned by this command must not overlap.

Valid Usage (Implicit)

VUID-vkGetPhysicalDevicePresentRectanglesKHR-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDevicePresentRectanglesKHR-surface-parameter
surface must be a valid VkSurfaceKHR handle
VUID-vkGetPhysicalDevicePresentRectanglesKHR-pRectCount-parameter
pRectCount must be a valid pointer to a uint32_t value
VUID-vkGetPhysicalDevicePresentRectanglesKHR-pRects-parameter
If the value referenced by pRectCount is not 0, and pRects is not NULL, pRects must be a valid pointer to an array of pRectCount VkRect2D structures
VUID-vkGetPhysicalDevicePresentRectanglesKHR-commonparent
Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance

Host Synchronization

Host access to surface must be externally synchronized

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

32.8. Display Timing Queries

Traditional game and real-time-animation applications frequently use VK_PRESENT_MODE_FIFO_KHR so that presentable images are updated during the vertical blanking period of a given refresh cycle (RC) of the presentation engine’s display. This avoids the visual anomaly known as tearing.

However, synchronizing the presentation of images with the RC does not prevent all forms of visual anomalies. Stuttering occurs when the geometry for each presentable image is not accurately positioned for when that image will be displayed. The geometry may appear to move too little some RCs, and too much for others. Sometimes the animation appears to freeze, when the same image is used for more than one RC.

In order to minimize stuttering, an application needs to correctly position their geometry for when the presentable image will be displayed to the user. To accomplish this, applications need various timing information about the presentation engine’s display. They need to know when presentable images were actually presented, and when they could have been presented. Applications also need to tell the presentation engine to display an image no sooner than a given time. This can allow the application’s animation to look smooth to the user, with no stuttering. The VK_GOOGLE_display_timing extension allows an application to satisfy these needs.

The presentation engine’s display typically refreshes the pixels that are displayed to the user on a periodic basis. The period may be fixed or variable. In many cases, the presentation engine is associated with fixed refresh rate (FRR) display technology, with a fixed refresh rate (RR, e.g. 60Hz). In some cases, the presentation engine is associated with variable refresh rate (VRR) display technology, where each refresh cycle (RC) can vary in length. This extension treats VRR displays as if they are FRR.

To query the duration of a refresh cycle (RC) for the presentation engine’s display, call:

VkResult vkGetRefreshCycleDurationGOOGLE(
    VkDevice                                    device,
    VkSwapchainKHR                              swapchain,
    VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties);

device is the device associated with swapchain.
swapchain is the swapchain to obtain the refresh duration for.
pDisplayTimingProperties is a pointer to a VkRefreshCycleDurationGOOGLE structure.

Valid Usage (Implicit)

VUID-vkGetRefreshCycleDurationGOOGLE-device-parameter
device must be a valid VkDevice handle
VUID-vkGetRefreshCycleDurationGOOGLE-swapchain-parameter
swapchain must be a valid VkSwapchainKHR handle
VUID-vkGetRefreshCycleDurationGOOGLE-pDisplayTimingProperties-parameter
pDisplayTimingProperties must be a valid pointer to a VkRefreshCycleDurationGOOGLE structure
VUID-vkGetRefreshCycleDurationGOOGLE-commonparent
Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance

Host Synchronization

Host access to swapchain must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_DEVICE_LOST
VK_ERROR_SURFACE_LOST_KHR

The VkRefreshCycleDurationGOOGLE structure is defined as:

typedef struct VkRefreshCycleDurationGOOGLE {
    uint64_t    refreshDuration;
} VkRefreshCycleDurationGOOGLE;

refreshDuration is the number of nanoseconds from the start of one refresh cycle to the next.

Note

The rate at which an application renders and presents new images is known as the image present rate (IPR, aka frame rate). The inverse of IPR, or the duration between each image present, is the image present duration (IPD). In order to provide a smooth, stutter-free animation, an application will want its IPD to be a multiple of refreshDuration. For example, if a display has a 60Hz refresh rate, refreshDuration will be a value in nanoseconds that is approximately equal to 16.67ms. In such a case, an application will want an IPD of 16.67ms (1X multiplier of refreshDuration), or 33.33ms (2X multiplier of refreshDuration), or 50.0ms (3X multiplier of refreshDuration), etc.

In order to determine a target IPD for a display (i.e. a multiple of refreshDuration), an application needs to determine when its images are actually displayed. Let’s say that an application has an initial target IPD of 16.67ms (1X multiplier of refreshDuration). It will therefore position the geometry of a new image 16.67ms later than the previous image. Let’s say that this application is running on slower hardware, so that it actually takes 20ms to render each new image. This will create visual anomalies, because the images will not be displayed to the user every 16.67ms, nor every 20ms. In this case, it is better for the application to adjust its target IPD to 33.33ms (i.e. a 2X multiplier of refreshDuration), and tell the presentation engine to not present images any sooner than every 33.33ms. This will allow the geometry to be correctly positioned for each presentable image.

Adjustments to an application’s IPD may be needed because different views of an application’s geometry can take different amounts of time to render. For example, looking at the sky may take less time to render than looking at multiple, complex items in a room. In general, it is good to not frequently change IPD, as that can cause visual anomalies. Adjustments to a larger IPD because of late images should happen quickly, but adjustments to a smaller IPD should only happen if the actualPresentTime and earliestPresentTime members of the VkPastPresentationTimingGOOGLE structure are consistently different, and if presentMargin is consistently large, over multiple images.

The implementation will maintain a limited amount of history of timing information about previous presents. Because of the asynchronous nature of the presentation engine, the timing information for a given vkQueuePresentKHR command will become available some time later. These time values can be asynchronously queried, and will be returned if available. All time values are in nanoseconds, relative to a monotonically-increasing clock (e.g. CLOCK_MONOTONIC (see clock_gettime(2)) on Android and Linux).

To asynchronously query the presentation engine, for newly-available timing information about one or more previous presents to a given swapchain, call:

VkResult vkGetPastPresentationTimingGOOGLE(
    VkDevice                                    device,
    VkSwapchainKHR                              swapchain,
    uint32_t*                                   pPresentationTimingCount,
    VkPastPresentationTimingGOOGLE*             pPresentationTimings);

device is the device associated with swapchain.
swapchain is the swapchain to obtain presentation timing information duration for.
pPresentationTimingCount is a pointer to an integer related to the number of VkPastPresentationTimingGOOGLE structures to query, as described below.
pPresentationTimings is either NULL or a pointer to an array of VkPastPresentationTimingGOOGLE structures.

If pPresentationTimings is NULL, then the number of newly-available timing records for the given swapchain is returned in pPresentationTimingCount. Otherwise, pPresentationTimingCount must point to a variable set by the user to the number of elements in the pPresentationTimings array, and on return the variable is overwritten with the number of structures actually written to pPresentationTimings. If the value of pPresentationTimingCount is less than the number of newly-available timing records, at most pPresentationTimingCount structures will be written. If pPresentationTimingCount is smaller than the number of newly-available timing records for the given swapchain, VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned.

Valid Usage (Implicit)

VUID-vkGetPastPresentationTimingGOOGLE-device-parameter
device must be a valid VkDevice handle
VUID-vkGetPastPresentationTimingGOOGLE-swapchain-parameter
swapchain must be a valid VkSwapchainKHR handle
VUID-vkGetPastPresentationTimingGOOGLE-pPresentationTimingCount-parameter
pPresentationTimingCount must be a valid pointer to a uint32_t value
VUID-vkGetPastPresentationTimingGOOGLE-pPresentationTimings-parameter
If the value referenced by pPresentationTimingCount is not 0, and pPresentationTimings is not NULL, pPresentationTimings must be a valid pointer to an array of pPresentationTimingCount VkPastPresentationTimingGOOGLE structures
VUID-vkGetPastPresentationTimingGOOGLE-commonparent
Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance

Host Synchronization

Host access to swapchain must be externally synchronized

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_DEVICE_LOST
VK_ERROR_OUT_OF_DATE_KHR
VK_ERROR_SURFACE_LOST_KHR

The VkPastPresentationTimingGOOGLE structure is defined as:

typedef struct VkPastPresentationTimingGOOGLE {
    uint32_t    presentID;
    uint64_t    desiredPresentTime;
    uint64_t    actualPresentTime;
    uint64_t    earliestPresentTime;
    uint64_t    presentMargin;
} VkPastPresentationTimingGOOGLE;

presentID is an application-provided value that was given to a previous vkQueuePresentKHR command via VkPresentTimeGOOGLE::presentID (see below). It can be used to uniquely identify a previous present with the vkQueuePresentKHR command.
desiredPresentTime is an application-provided value that was given to a previous vkQueuePresentKHR command via VkPresentTimeGOOGLE::desiredPresentTime. If non-zero, it was used by the application to indicate that an image not be presented any sooner than desiredPresentTime.
actualPresentTime is the time when the image of the swapchain was actually displayed.
earliestPresentTime is the time when the image of the swapchain could have been displayed. This may differ from actualPresentTime if the application requested that the image be presented no sooner than VkPresentTimeGOOGLE::desiredPresentTime.
presentMargin is an indication of how early the vkQueuePresentKHR command was processed compared to how soon it needed to be processed, and still be presented at earliestPresentTime.

The results for a given swapchain and presentID are only returned once from vkGetPastPresentationTimingGOOGLE.

The application can use the VkPastPresentationTimingGOOGLE values to occasionally adjust its timing. For example, if actualPresentTime is later than expected (e.g. one refreshDuration late), the application may increase its target IPD to a higher multiple of refreshDuration (e.g. decrease its frame rate from 60Hz to 30Hz). If actualPresentTime and earliestPresentTime are consistently different, and if presentMargin is consistently large enough, the application may decrease its target IPD to a smaller multiple of refreshDuration (e.g. increase its frame rate from 30Hz to 60Hz). If actualPresentTime and earliestPresentTime are same, and if presentMargin is consistently high, the application may delay the start of its input-render-present loop in order to decrease the latency between user input and the corresponding present (always leaving some margin in case a new image takes longer to render than the previous image). An application that desires its target IPD to always be the same as refreshDuration, can also adjust features until actualPresentTime is never late and presentMargin is satisfactory.

The full VK_GOOGLE_display_timing extension semantics are described for swapchains created with VK_PRESENT_MODE_FIFO_KHR. For example, non-zero values of VkPresentTimeGOOGLE::desiredPresentTime must be honored, and vkGetPastPresentationTimingGOOGLE should return a VkPastPresentationTimingGOOGLE structure with valid values for all images presented with vkQueuePresentKHR. The semantics for other present modes are as follows:

VK_PRESENT_MODE_IMMEDIATE_KHR. The presentation engine may ignore non-zero values of VkPresentTimeGOOGLE::desiredPresentTime in favor of presenting immediately. The value of VkPastPresentationTimingGOOGLE::earliestPresentTime must be the same as VkPastPresentationTimingGOOGLE::actualPresentTime, which should be when the presentation engine displayed the image.
VK_PRESENT_MODE_MAILBOX_KHR. The intention of using this present mode with this extension is to handle cases where an image is presented late, and the next image is presented soon enough to replace it at the next vertical blanking period. For images that are displayed to the user, the value of VkPastPresentationTimingGOOGLE::actualPresentTime must be when the image was displayed. For images that are not displayed to the user, vkGetPastPresentationTimingGOOGLE may not return a VkPastPresentationTimingGOOGLE structure, or it may return a VkPastPresentationTimingGOOGLE structure with the value of zero for both VkPastPresentationTimingGOOGLE::actualPresentTime and VkPastPresentationTimingGOOGLE::earliestPresentTime. It is possible that an application can submit images with VkPresentTimeGOOGLE::desiredPresentTime values such that new images may not be displayed. For example, if VkPresentTimeGOOGLE::desiredPresentTime is far enough in the future that an image is not presented before vkQueuePresentKHR is called to present another image, the first image will not be displayed to the user. If the application continues to do that, the presentation may not display new images.
VK_PRESENT_MODE_FIFO_RELAXED_KHR. For images that are presented in time to be displayed at the next vertical blanking period, the semantics are identical as for VK_PRESENT_MODE_FIFO_RELAXED_KHR. For images that are presented late, and are displayed after the start of the vertical blanking period (i.e. with tearing), the values of VkPastPresentationTimingGOOGLE may be treated as if the image was displayed at the start of the vertical blanking period, or may be treated the same as for VK_PRESENT_MODE_IMMEDIATE_KHR.

32.9. WSI Swapchain

A swapchain object (a.k.a. swapchain) provides the ability to present rendering results to a surface. Swapchain objects are represented by VkSwapchainKHR handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)

A swapchain is an abstraction for an array of presentable images that are associated with a surface. The presentable images are represented by VkImage objects created by the platform. One image (which can be an array image for multiview/stereoscopic-3D surfaces) is displayed at a time, but multiple images can be queued for presentation. An application renders to the image, and then queues the image for presentation to the surface.

A native window cannot be associated with more than one non-retired swapchain at a time. Further, swapchains cannot be created for native windows that have a non-Vulkan graphics API surface associated with them.

Note

The presentation engine is an abstraction for the platform’s compositor or display engine.

The presentation engine may be synchronous or asynchronous with respect to the application and/or logical device.

Some implementations may use the device’s graphics queue or dedicated presentation hardware to perform presentation.

The presentable images of a swapchain are owned by the presentation engine. An application can acquire use of a presentable image from the presentation engine. Use of a presentable image must occur only after the image is returned by vkAcquireNextImageKHR, and before it is presented by vkQueuePresentKHR. This includes transitioning the image layout and rendering commands.

An application can acquire use of a presentable image with vkAcquireNextImageKHR. After acquiring a presentable image and before modifying it, the application must use a synchronization primitive to ensure that the presentation engine has finished reading from the image. The application can then transition the image’s layout, queue rendering commands to it, etc. Finally, the application presents the image with vkQueuePresentKHR, which releases the acquisition of the image.

The presentation engine controls the order in which presentable images are acquired for use by the application.

Note

This allows the platform to handle situations which require out-of-order return of images after presentation. At the same time, it allows the application to generate command buffers referencing all of the images in the swapchain at initialization time, rather than in its main loop.

How this all works is described below.

If a swapchain is created with presentMode set to either VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR or VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR, a single presentable image can be acquired, referred to as a shared presentable image. A shared presentable image may be concurrently accessed by the application and the presentation engine, without transitioning the image’s layout after it is initially presented.

With VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR, the presentation engine is only required to update to the latest contents of a shared presentable image after a present. The application must call vkQueuePresentKHR to guarantee an update. However, the presentation engine may update from it at any time.
With VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR, the presentation engine will automatically present the latest contents of a shared presentable image during every refresh cycle. The application is only required to make one initial call to vkQueuePresentKHR, after which the presentation engine will update from it without any need for further present calls. The application can indicate the image contents have been updated by calling vkQueuePresentKHR, but this does not guarantee the timing of when updates will occur.

The presentation engine may access a shared presentable image at any time after it is first presented. To avoid tearing, an application should coordinate access with the presentation engine. This requires presentation engine timing information through platform-specific mechanisms and ensuring that color attachment writes are made available during the portion of the presentation engine’s refresh cycle they are intended for.

Note

The VK_KHR_shared_presentable_image extension does not provide functionality for determining the timing of the presentation engine’s refresh cycles.

In order to query a swapchain’s status when rendering to a shared presentable image, call:

VkResult vkGetSwapchainStatusKHR(
    VkDevice                                    device,
    VkSwapchainKHR                              swapchain);

device is the device associated with swapchain.
swapchain is the swapchain to query.

Valid Usage (Implicit)

VUID-vkGetSwapchainStatusKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkGetSwapchainStatusKHR-swapchain-parameter
swapchain must be a valid VkSwapchainKHR handle
VUID-vkGetSwapchainStatusKHR-commonparent
Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance

Host Synchronization

Host access to swapchain must be externally synchronized

Return Codes

VK_SUCCESS
VK_SUBOPTIMAL_KHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST
VK_ERROR_OUT_OF_DATE_KHR
VK_ERROR_SURFACE_LOST_KHR
VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT

The possible return values for vkGetSwapchainStatusKHR should be interpreted as follows:

VK_SUCCESS specifies the presentation engine is presenting the contents of the shared presentable image, as per the swapchain’s VkPresentModeKHR.
VK_SUBOPTIMAL_KHR the swapchain no longer matches the surface properties exactly, but the presentation engine is presenting the contents of the shared presentable image, as per the swapchain’s VkPresentModeKHR.
VK_ERROR_OUT_OF_DATE_KHR the surface has changed in such a way that it is no longer compatible with the swapchain.
VK_ERROR_SURFACE_LOST_KHR the surface is no longer available.

Note

The swapchain state may be cached by implementations, so applications should regularly call vkGetSwapchainStatusKHR when using a swapchain with VkPresentModeKHR set to VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR.

To create a swapchain, call:

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

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

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

Note

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

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

Note

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

Valid Usage (Implicit)

VUID-vkCreateSwapchainKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateSwapchainKHR-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkSwapchainCreateInfoKHR structure
VUID-vkCreateSwapchainKHR-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateSwapchainKHR-pSwapchain-parameter
pSwapchain must be a valid pointer to a VkSwapchainKHR handle

Host Synchronization

Host access to pCreateInfo.surface must be externally synchronized
Host access to pCreateInfo.oldSwapchain must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST
VK_ERROR_SURFACE_LOST_KHR
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR
VK_ERROR_INITIALIZATION_FAILED

The VkSwapchainCreateInfoKHR structure is defined as:

typedef struct VkSwapchainCreateInfoKHR {
    VkStructureType                  sType;
    const void*                      pNext;
    VkSwapchainCreateFlagsKHR        flags;
    VkSurfaceKHR                     surface;
    uint32_t                         minImageCount;
    VkFormat                         imageFormat;
    VkColorSpaceKHR                  imageColorSpace;
    VkExtent2D                       imageExtent;
    uint32_t                         imageArrayLayers;
    VkImageUsageFlags                imageUsage;
    VkSharingMode                    imageSharingMode;
    uint32_t                         queueFamilyIndexCount;
    const uint32_t*                  pQueueFamilyIndices;
    VkSurfaceTransformFlagBitsKHR    preTransform;
    VkCompositeAlphaFlagBitsKHR      compositeAlpha;
    VkPresentModeKHR                 presentMode;
    VkBool32                         clipped;
    VkSwapchainKHR                   oldSwapchain;
} VkSwapchainCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkSwapchainCreateFlagBitsKHR indicating parameters of the swapchain creation.
surface is the surface onto which the swapchain will present images. If the creation succeeds, the swapchain becomes associated with surface.
minImageCount is the minimum number of presentable images that the application needs. The implementation will either create the swapchain with at least that many images, or it will fail to create the swapchain.
imageFormat is a VkFormat value specifying the format the swapchain image(s) will be created with.
imageColorSpace is a VkColorSpaceKHR value specifying the way the swapchain interprets image data.
imageExtent is the size (in pixels) of the swapchain image(s). The behavior is platform-dependent if the image extent does not match the surface’s currentExtent as returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR.

Note

On some platforms, it is normal that maxImageExtent may become (0, 0), for example when the window is minimized. In such a case, it is not possible to create a swapchain due to the Valid Usage requirements.

imageArrayLayers is the number of views in a multiview/stereo surface. For non-stereoscopic-3D applications, this value is 1.
imageUsage is a bitmask of VkImageUsageFlagBits describing the intended usage of the (acquired) swapchain images.
imageSharingMode is the sharing mode used for the image(s) of the swapchain.
queueFamilyIndexCount is the number of queue families having access to the image(s) of the swapchain when imageSharingMode is VK_SHARING_MODE_CONCURRENT.
pQueueFamilyIndices is a pointer to an array of queue family indices having access to the images(s) of the swapchain when imageSharingMode is VK_SHARING_MODE_CONCURRENT.
preTransform is a VkSurfaceTransformFlagBitsKHR value describing the transform, relative to the presentation engine’s natural orientation, applied to the image content prior to presentation. If it does not match the currentTransform value returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR, the presentation engine will transform the image content as part of the presentation operation.
compositeAlpha is a VkCompositeAlphaFlagBitsKHR value indicating the alpha compositing mode to use when this surface is composited together with other surfaces on certain window systems.
presentMode is the presentation mode the swapchain will use. A swapchain’s present mode determines how incoming present requests will be processed and queued internally.
clipped specifies whether the Vulkan implementation is allowed to discard rendering operations that affect regions of the surface that are not visible.
- If set to VK_TRUE, the presentable images associated with the swapchain may not own all of their pixels. Pixels in the presentable images that correspond to regions of the target surface obscured by another window on the desktop, or subject to some other clipping mechanism will have undefined content when read back. Fragment shaders may not execute for these pixels, and thus any side effects they would have had will not occur. VK_TRUE value does not guarantee any clipping will occur, but allows more optimal presentation methods to be used on some platforms.
- If set to VK_FALSE, presentable images associated with the swapchain will own all of the pixels they contain.

Note

Applications should set this value to VK_TRUE if they do not expect to read back the content of presentable images before presenting them or after reacquiring them, and if their fragment shaders do not have any side effects that require them to run for all pixels in the presentable image.

oldSwapchain is VK_NULL_HANDLE, or the existing non-retired swapchain currently associated with surface. Providing a valid oldSwapchain may aid in the resource reuse, and also allows the application to still present any images that are already acquired from it.

Upon calling vkCreateSwapchainKHR with an oldSwapchain that is not VK_NULL_HANDLE, oldSwapchain is retired — even if creation of the new swapchain fails. The new swapchain is created in the non-retired state whether or not oldSwapchain is VK_NULL_HANDLE.

Upon calling vkCreateSwapchainKHR with an oldSwapchain that is not VK_NULL_HANDLE, any images from oldSwapchain that are not acquired by the application may be freed by the implementation, which may occur even if creation of the new swapchain fails. The application can destroy oldSwapchain to free all memory associated with oldSwapchain.

Note

Multiple retired swapchains can be associated with the same VkSurfaceKHR through multiple uses of oldSwapchain that outnumber calls to vkDestroySwapchainKHR.

After oldSwapchain is retired, the application can pass to vkQueuePresentKHR any images it had already acquired from oldSwapchain. E.g., an application may present an image from the old swapchain before an image from the new swapchain is ready to be presented. As usual, vkQueuePresentKHR may fail if oldSwapchain has entered a state that causes VK_ERROR_OUT_OF_DATE_KHR to be returned.

The application can continue to use a shared presentable image obtained from oldSwapchain until a presentable image is acquired from the new swapchain, as long as it has not entered a state that causes it to return VK_ERROR_OUT_OF_DATE_KHR.

Valid Usage

VUID-VkSwapchainCreateInfoKHR-surface-01270
surface must be a surface that is supported by the device as determined using vkGetPhysicalDeviceSurfaceSupportKHR
VUID-VkSwapchainCreateInfoKHR-minImageCount-01272
minImageCount must be less than or equal to the value returned in the maxImageCount member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface if the returned maxImageCount is not zero
VUID-VkSwapchainCreateInfoKHR-presentMode-02839
If presentMode is not VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR nor VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR, then minImageCount must be greater than or equal to the value returned in the minImageCount member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface
VUID-VkSwapchainCreateInfoKHR-minImageCount-01383
minImageCount must be 1 if presentMode is either VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR or VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR
VUID-VkSwapchainCreateInfoKHR-imageFormat-01273
imageFormat and imageColorSpace must match the format and colorSpace members, respectively, of one of the VkSurfaceFormatKHR structures returned by vkGetPhysicalDeviceSurfaceFormatsKHR for the surface
VUID-VkSwapchainCreateInfoKHR-imageExtent-01274
imageExtent must be between minImageExtent and maxImageExtent, inclusive, where minImageExtent and maxImageExtent are members of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface
VUID-VkSwapchainCreateInfoKHR-imageExtent-01689
imageExtent members width and height must both be non-zero
VUID-VkSwapchainCreateInfoKHR-imageArrayLayers-01275
imageArrayLayers must be greater than 0 and less than or equal to the maxImageArrayLayers member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface
VUID-VkSwapchainCreateInfoKHR-presentMode-01427
If presentMode is VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR or VK_PRESENT_MODE_FIFO_RELAXED_KHR, imageUsage must be a subset of the supported usage flags present in the supportedUsageFlags member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for surface
VUID-VkSwapchainCreateInfoKHR-imageUsage-01384
If presentMode is VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR or VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR, imageUsage must be a subset of the supported usage flags present in the sharedPresentSupportedUsageFlags member of the VkSharedPresentSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilities2KHR for surface
VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01277
If imageSharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values
VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01278
If imageSharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1
VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01428
If imageSharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device
VUID-VkSwapchainCreateInfoKHR-preTransform-01279
preTransform must be one of the bits present in the supportedTransforms member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface
VUID-VkSwapchainCreateInfoKHR-compositeAlpha-01280
compositeAlpha must be one of the bits present in the supportedCompositeAlpha member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface
VUID-VkSwapchainCreateInfoKHR-presentMode-01281
presentMode must be one of the VkPresentModeKHR values returned by vkGetPhysicalDeviceSurfacePresentModesKHR for the surface
VUID-VkSwapchainCreateInfoKHR-physicalDeviceCount-01429
If the logical device was created with VkDeviceGroupDeviceCreateInfo::physicalDeviceCount equal to 1, flags must not contain VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR
VUID-VkSwapchainCreateInfoKHR-oldSwapchain-01933
If oldSwapchain is not VK_NULL_HANDLE, oldSwapchain must be a non-retired swapchain associated with native window referred to by surface
VUID-VkSwapchainCreateInfoKHR-imageFormat-01778
The implied image creation parameters of the swapchain must be supported as reported by vkGetPhysicalDeviceImageFormatProperties
VUID-VkSwapchainCreateInfoKHR-flags-03168
If flags contains VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR then the pNext chain must include a VkImageFormatListCreateInfo structure with a viewFormatCount greater than zero and pViewFormats must have an element equal to imageFormat
VUID-VkSwapchainCreateInfoKHR-flags-03187
If flags contains VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR, then VkSurfaceProtectedCapabilitiesKHR::supportsProtected must be VK_TRUE in the VkSurfaceProtectedCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilities2KHR for surface
VUID-VkSwapchainCreateInfoKHR-pNext-02679
If the pNext chain includes a VkSurfaceFullScreenExclusiveInfoEXT structure with its fullScreenExclusive member set to VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT, and surface was created using vkCreateWin32SurfaceKHR, a VkSurfaceFullScreenExclusiveWin32InfoEXT structure must be included in the pNext chain

Valid Usage (Implicit)

VUID-VkSwapchainCreateInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
VUID-VkSwapchainCreateInfoKHR-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupSwapchainCreateInfoKHR, VkImageFormatListCreateInfo, VkSurfaceFullScreenExclusiveInfoEXT, VkSurfaceFullScreenExclusiveWin32InfoEXT, VkSwapchainCounterCreateInfoEXT, or VkSwapchainDisplayNativeHdrCreateInfoAMD
VUID-VkSwapchainCreateInfoKHR-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkSwapchainCreateInfoKHR-flags-parameter
flags must be a valid combination of VkSwapchainCreateFlagBitsKHR values
VUID-VkSwapchainCreateInfoKHR-surface-parameter
surface must be a valid VkSurfaceKHR handle
VUID-VkSwapchainCreateInfoKHR-imageFormat-parameter
imageFormat must be a valid VkFormat value
VUID-VkSwapchainCreateInfoKHR-imageColorSpace-parameter
imageColorSpace must be a valid VkColorSpaceKHR value
VUID-VkSwapchainCreateInfoKHR-imageUsage-parameter
imageUsage must be a valid combination of VkImageUsageFlagBits values
VUID-VkSwapchainCreateInfoKHR-imageUsage-requiredbitmask
imageUsage must not be 0
VUID-VkSwapchainCreateInfoKHR-imageSharingMode-parameter
imageSharingMode must be a valid VkSharingMode value
VUID-VkSwapchainCreateInfoKHR-preTransform-parameter
preTransform must be a valid VkSurfaceTransformFlagBitsKHR value
VUID-VkSwapchainCreateInfoKHR-compositeAlpha-parameter
compositeAlpha must be a valid VkCompositeAlphaFlagBitsKHR value
VUID-VkSwapchainCreateInfoKHR-presentMode-parameter
presentMode must be a valid VkPresentModeKHR value
VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parameter
If oldSwapchain is not VK_NULL_HANDLE, oldSwapchain must be a valid VkSwapchainKHR handle
VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parent
If oldSwapchain is a valid handle, it must have been created, allocated, or retrieved from surface
VUID-VkSwapchainCreateInfoKHR-commonparent
Both of oldSwapchain, and surface that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkInstance

Bits which can be set in VkSwapchainCreateInfoKHR::flags, specifying parameters of swapchain creation, are:

typedef enum VkSwapchainCreateFlagBitsKHR {
    VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001,
    VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002,
    VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004,
    VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkSwapchainCreateFlagBitsKHR;

VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR specifies that images created from the swapchain (i.e. with the swapchain member of VkImageSwapchainCreateInfoKHR set to this swapchain’s handle) must use VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT.
VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR specifies that images created from the swapchain are protected images.
VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR specifies that the images of the swapchain can be used to create a VkImageView with a different format than what the swapchain was created with. The list of allowed image view formats are specified by adding a VkImageFormatListCreateInfo structure to the pNext chain of VkSwapchainCreateInfoKHR. In addition, this flag also specifies that the swapchain can be created with usage flags that are not supported for the format the swapchain is created with but are supported for at least one of the allowed image view formats.

typedef VkFlags VkSwapchainCreateFlagsKHR;

VkSwapchainCreateFlagsKHR is a bitmask type for setting a mask of zero or more VkSwapchainCreateFlagBitsKHR.

If the pNext chain of VkSwapchainCreateInfoKHR includes a VkDeviceGroupSwapchainCreateInfoKHR structure, then that structure includes a set of device group present modes that the swapchain can be used with.

The VkDeviceGroupSwapchainCreateInfoKHR structure is defined as:

typedef struct VkDeviceGroupSwapchainCreateInfoKHR {
    VkStructureType                     sType;
    const void*                         pNext;
    VkDeviceGroupPresentModeFlagsKHR    modes;
} VkDeviceGroupSwapchainCreateInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
modes is a bitfield of modes that the swapchain can be used with.

If this structure is not present, modes is considered to be VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR.

Valid Usage (Implicit)

VUID-VkDeviceGroupSwapchainCreateInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR
VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-parameter
modes must be a valid combination of VkDeviceGroupPresentModeFlagBitsKHR values
VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-requiredbitmask
modes must not be 0

If the pNext chain of VkSwapchainCreateInfoKHR includes a VkSwapchainDisplayNativeHdrCreateInfoAMD structure, then that structure includes additional swapchain creation parameters specific to display native HDR support.

The VkSwapchainDisplayNativeHdrCreateInfoAMD structure is defined as:

typedef struct VkSwapchainDisplayNativeHdrCreateInfoAMD {
    VkStructureType    sType;
    const void*        pNext;
    VkBool32           localDimmingEnable;
} VkSwapchainDisplayNativeHdrCreateInfoAMD;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
localDimmingEnable specifies whether local dimming is enabled for the swapchain.

If the pNext chain of VkSwapchainCreateInfoKHR does not include this structure, the default value for localDimmingEnable is VK_TRUE, meaning local dimming is initially enabled for the swapchain.

Valid Usage (Implicit)

VUID-VkSwapchainDisplayNativeHdrCreateInfoAMD-sType-sType
sType must be VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD

Valid Usage

VUID-VkSwapchainDisplayNativeHdrCreateInfoAMD-localDimmingEnable-XXXXX
It is only valid to set localDimmingEnable to VK_TRUE if VkDisplayNativeHdrSurfaceCapabilitiesAMD::localDimmingSupport is supported.

The local dimming HDR setting may also be changed over the life of a swapchain by calling:

void vkSetLocalDimmingAMD(
    VkDevice                                    device,
    VkSwapchainKHR                              swapChain,
    VkBool32                                    localDimmingEnable);

device is the device associated with swapChain.
swapChain handle to enable local dimming.
localDimmingEnable specifies whether local dimming is enabled for the swapchain.

Valid Usage (Implicit)

VUID-vkSetLocalDimmingAMD-device-parameter
device must be a valid VkDevice handle
VUID-vkSetLocalDimmingAMD-swapChain-parameter
swapChain must be a valid VkSwapchainKHR handle
VUID-vkSetLocalDimmingAMD-commonparent
Both of device, and swapChain must have been created, allocated, or retrieved from the same VkInstance

Valid Usage

VUID-vkSetLocalDimmingAMD-XXXXX
It is only valid to call vkSetLocalDimmingAMD if VkDisplayNativeHdrSurfaceCapabilitiesAMD::localDimmingSupport is supported.

If the pNext chain of VkSwapchainCreateInfoKHR includes a VkSurfaceFullScreenExclusiveInfoEXT structure, then that structure specifies the application’s preferred full-screen presentation behavior. If this structure is not present, fullScreenExclusive is considered to be VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT.

To enable surface counters when creating a swapchain, add a VkSwapchainCounterCreateInfoEXT structure to the pNext chain of VkSwapchainCreateInfoKHR. VkSwapchainCounterCreateInfoEXT is defined as:

typedef struct VkSwapchainCounterCreateInfoEXT {
    VkStructureType             sType;
    const void*                 pNext;
    VkSurfaceCounterFlagsEXT    surfaceCounters;
} VkSwapchainCounterCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
surfaceCounters is a bitmask of VkSurfaceCounterFlagBitsEXT specifying surface counters to enable for the swapchain.

Valid Usage

VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-01244
The bits in surfaceCounters must be supported by VkSwapchainCreateInfoKHR::surface, as reported by vkGetPhysicalDeviceSurfaceCapabilities2EXT.

Valid Usage (Implicit)

VUID-VkSwapchainCounterCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT
VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-parameter
surfaceCounters must be a valid combination of VkSurfaceCounterFlagBitsEXT values

The requested counters become active when the first presentation command for the associated swapchain is processed by the presentation engine. To query the value of an active counter, use:

VkResult vkGetSwapchainCounterEXT(
    VkDevice                                    device,
    VkSwapchainKHR                              swapchain,
    VkSurfaceCounterFlagBitsEXT                 counter,
    uint64_t*                                   pCounterValue);

device is the VkDevice associated with swapchain.
swapchain is the swapchain from which to query the counter value.
counter is the counter to query.
pCounterValue will return the current value of the counter.

If a counter is not available because the swapchain is out of date, the implementation may return VK_ERROR_OUT_OF_DATE_KHR.

Valid Usage

VUID-vkGetSwapchainCounterEXT-swapchain-01245
One or more present commands on swapchain must have been processed by the presentation engine.

Valid Usage (Implicit)

VUID-vkGetSwapchainCounterEXT-device-parameter
device must be a valid VkDevice handle
VUID-vkGetSwapchainCounterEXT-swapchain-parameter
swapchain must be a valid VkSwapchainKHR handle
VUID-vkGetSwapchainCounterEXT-counter-parameter
counter must be a valid VkSurfaceCounterFlagBitsEXT value
VUID-vkGetSwapchainCounterEXT-pCounterValue-parameter
pCounterValue must be a valid pointer to a uint64_t value
VUID-vkGetSwapchainCounterEXT-commonparent
Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance

Return Codes

VK_SUCCESS

VK_ERROR_DEVICE_LOST
VK_ERROR_OUT_OF_DATE_KHR

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

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

VkImageCreateInfo Field Value

flags

VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT is set if VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR is set

VK_IMAGE_CREATE_PROTECTED_BIT is set if VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR is set

VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT and VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR are both set if VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR is set

all other bits are unset

imageType

VK_IMAGE_TYPE_2D

format

pCreateInfo->imageFormat

extent

{pCreateInfo->imageExtent.width, pCreateInfo->imageExtent.height, 1}

mipLevels

arrayLayers

pCreateInfo->imageArrayLayers

samples

VK_SAMPLE_COUNT_1_BIT

tiling

VK_IMAGE_TILING_OPTIMAL

usage

pCreateInfo->imageUsage

sharingMode

pCreateInfo->imageSharingMode

queueFamilyIndexCount

pCreateInfo->queueFamilyIndexCount

pQueueFamilyIndices

pCreateInfo->pQueueFamilyIndices

initialLayout

VK_IMAGE_LAYOUT_UNDEFINED

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

If oldSwapchain is VK_NULL_HANDLE, and the native window referred to by surface is already associated with a Vulkan swapchain, VK_ERROR_NATIVE_WINDOW_IN_USE_KHR must be returned.

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

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

Like core functions, several WSI functions, including vkCreateSwapchainKHR return VK_ERROR_DEVICE_LOST if the logical device was lost. See Lost Device. As with most core objects, VkSwapchainKHR is a child of the device and is affected by the lost state; it must be destroyed before destroying the VkDevice. However, VkSurfaceKHR is not a child of any VkDevice and is not otherwise affected by the lost device. After successfully recreating a VkDevice, the same VkSurfaceKHR can be used to create a new VkSwapchainKHR, provided the previous one was destroyed.

Note

As mentioned in Lost Device, after a lost device event, the VkPhysicalDevice may also be lost. If other VkPhysicalDevice are available, they can be used together with the same VkSurfaceKHR to create the new VkSwapchainKHR, however the application must query the surface capabilities again, because they may differ on a per-physical device basis.

To destroy a swapchain object call:

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

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

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

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

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

Valid Usage

VUID-vkDestroySwapchainKHR-swapchain-01282
All uses of presentable images acquired from swapchain must have completed execution
VUID-vkDestroySwapchainKHR-swapchain-01283
If VkAllocationCallbacks were provided when swapchain was created, a compatible set of callbacks must be provided here
VUID-vkDestroySwapchainKHR-swapchain-01284
If no VkAllocationCallbacks were provided when swapchain was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroySwapchainKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkDestroySwapchainKHR-swapchain-parameter
If swapchain is not VK_NULL_HANDLE, swapchain must be a valid VkSwapchainKHR handle
VUID-vkDestroySwapchainKHR-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroySwapchainKHR-commonparent
Both of device, and swapchain that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkInstance

Host Synchronization

Host access to swapchain must be externally synchronized

When the VK_KHR_display_swapchain extension is enabled, multiple swapchains that share presentable images are created by calling:

VkResult vkCreateSharedSwapchainsKHR(
    VkDevice                                    device,
    uint32_t                                    swapchainCount,
    const VkSwapchainCreateInfoKHR*             pCreateInfos,
    const VkAllocationCallbacks*                pAllocator,
    VkSwapchainKHR*                             pSwapchains);

device is the device to create the swapchains for.
swapchainCount is the number of swapchains to create.
pCreateInfos is a pointer to an array of VkSwapchainCreateInfoKHR structures specifying the parameters of the created swapchains.
pAllocator is the allocator used for host memory allocated for the swapchain objects when there is no more specific allocator available (see Memory Allocation).
pSwapchains is a pointer to an array of VkSwapchainKHR handles in which the created swapchain objects will be returned.

vkCreateSharedSwapchainsKHR is similar to vkCreateSwapchainKHR, except that it takes an array of VkSwapchainCreateInfoKHR structures, and returns an array of swapchain objects.

The swapchain creation parameters that affect the properties and number of presentable images must match between all the swapchains. If the displays used by any of the swapchains do not use the same presentable image layout or are incompatible in a way that prevents sharing images, swapchain creation will fail with the result code VK_ERROR_INCOMPATIBLE_DISPLAY_KHR. If any error occurs, no swapchains will be created. Images presented to multiple swapchains must be re-acquired from all of them before transitioning away from VK_IMAGE_LAYOUT_PRESENT_SRC_KHR. After destroying one or more of the swapchains, the remaining swapchains and the presentable images can continue to be used.

Valid Usage (Implicit)

VUID-vkCreateSharedSwapchainsKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkCreateSharedSwapchainsKHR-pCreateInfos-parameter
pCreateInfos must be a valid pointer to an array of swapchainCount valid VkSwapchainCreateInfoKHR structures
VUID-vkCreateSharedSwapchainsKHR-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateSharedSwapchainsKHR-pSwapchains-parameter
pSwapchains must be a valid pointer to an array of swapchainCount VkSwapchainKHR handles
VUID-vkCreateSharedSwapchainsKHR-swapchainCount-arraylength
swapchainCount must be greater than 0

Host Synchronization

Host access to pCreateInfos[].surface must be externally synchronized
Host access to pCreateInfos[].oldSwapchain must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INCOMPATIBLE_DISPLAY_KHR
VK_ERROR_DEVICE_LOST
VK_ERROR_SURFACE_LOST_KHR

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

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

device is the device associated with swapchain.
swapchain is the swapchain to query.
pSwapchainImageCount is a pointer to an integer related to the number of presentable images available or queried, as described below.
pSwapchainImages is either NULL or a pointer to an array of VkImage handles.

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

Valid Usage (Implicit)

VUID-vkGetSwapchainImagesKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkGetSwapchainImagesKHR-swapchain-parameter
swapchain must be a valid VkSwapchainKHR handle
VUID-vkGetSwapchainImagesKHR-pSwapchainImageCount-parameter
pSwapchainImageCount must be a valid pointer to a uint32_t value
VUID-vkGetSwapchainImagesKHR-pSwapchainImages-parameter
If the value referenced by pSwapchainImageCount is not 0, and pSwapchainImages is not NULL, pSwapchainImages must be a valid pointer to an array of pSwapchainImageCount VkImage handles
VUID-vkGetSwapchainImagesKHR-commonparent
Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Note

By knowing all presentable images used in the swapchain, the application can create command buffers that reference these images prior to entering its main rendering loop.

Images returned by vkGetSwapchainImagesKHR are fully backed by memory before they are passed to the application. All presentable images are initially in the VK_IMAGE_LAYOUT_UNDEFINED layout, thus before using presentable images, the application must transition them to a valid layout for the intended use.

Further, the lifetime of presentable images is controlled by the implementation, so applications must not destroy a presentable image. See vkDestroySwapchainKHR for further details on the lifetime of presentable images.

Images can also be created by using vkCreateImage with VkImageSwapchainCreateInfoKHR and bound to swapchain memory using vkBindImageMemory2KHR with VkBindImageMemorySwapchainInfoKHR. These images can be used anywhere swapchain images are used, and are useful in logical devices with multiple physical devices to create peer memory bindings of swapchain memory. These images and bindings have no effect on what memory is presented. Unlike images retrieved from vkGetSwapchainImagesKHR, these images must be destroyed with vkDestroyImage.

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

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

device is the device associated with swapchain.
swapchain is the non-retired swapchain from which an image is being acquired.
timeout specifies how long the function waits, in nanoseconds, if no image is available.
semaphore is VK_NULL_HANDLE or a semaphore to signal.
fence is VK_NULL_HANDLE or a fence to signal.
pImageIndex is a pointer to a uint32_t in which the index of the next image to use (i.e. an index into the array of images returned by vkGetSwapchainImagesKHR) is returned.

Valid Usage

VUID-vkAcquireNextImageKHR-swapchain-01285
swapchain must not be in the retired state
VUID-vkAcquireNextImageKHR-semaphore-01286
If semaphore is not VK_NULL_HANDLE it must be unsignaled
VUID-vkAcquireNextImageKHR-semaphore-01779
If semaphore is not VK_NULL_HANDLE it must not have any uncompleted signal or wait operations pending
VUID-vkAcquireNextImageKHR-fence-01287
If fence is not VK_NULL_HANDLE it must be unsignaled and must not be associated with any other queue command that has not yet completed execution on that queue
VUID-vkAcquireNextImageKHR-semaphore-01780
semaphore and fence must not both be equal to VK_NULL_HANDLE
VUID-vkAcquireNextImageKHR-swapchain-01802
If the number of currently acquired images is greater than the difference between the number of images in swapchain and the value of VkSurfaceCapabilitiesKHR::minImageCount as returned by a call to vkGetPhysicalDeviceSurfaceCapabilities2KHR with the surface used to create swapchain, timeout must not be UINT64_MAX
VUID-vkAcquireNextImageKHR-semaphore-03265
semaphore must have a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY

Valid Usage (Implicit)

VUID-vkAcquireNextImageKHR-device-parameter
device must be a valid VkDevice handle
VUID-vkAcquireNextImageKHR-swapchain-parameter
swapchain must be a valid VkSwapchainKHR handle
VUID-vkAcquireNextImageKHR-semaphore-parameter
If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle
VUID-vkAcquireNextImageKHR-fence-parameter
If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle
VUID-vkAcquireNextImageKHR-pImageIndex-parameter
pImageIndex must be a valid pointer to a uint32_t value
VUID-vkAcquireNextImageKHR-semaphore-parent
If semaphore is a valid handle, it must have been created, allocated, or retrieved from device
VUID-vkAcquireNextImageKHR-fence-parent
If fence is a valid handle, it must have been created, allocated, or retrieved from device
VUID-vkAcquireNextImageKHR-commonparent
Both of device, and swapchain that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkInstance

Host Synchronization

Host access to swapchain must be externally synchronized
Host access to semaphore must be externally synchronized
Host access to fence must be externally synchronized

Return Codes

VK_SUCCESS
VK_TIMEOUT
VK_NOT_READY
VK_SUBOPTIMAL_KHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST
VK_ERROR_OUT_OF_DATE_KHR
VK_ERROR_SURFACE_LOST_KHR
VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT

When successful, vkAcquireNextImageKHR acquires a presentable image from swapchain that an application can use, and sets pImageIndex to the index of that image within the swapchain. The presentation engine may not have finished reading from the image at the time it is acquired, so the application must use semaphore and/or fence to ensure that the image layout and contents are not modified until the presentation engine reads have completed. If semaphore is not VK_NULL_HANDLE, the application may assume that, once vkAcquireNextImageKHR returns, the semaphore signal operation referenced by semaphore has been submitted for execution. The order in which images are acquired is implementation-dependent, and may be different than the order the images were presented.

If timeout is zero, then vkAcquireNextImageKHR does not wait, and will either successfully acquire an image, or fail and return VK_NOT_READY if no image is available.

If the specified timeout period expires before an image is acquired, vkAcquireNextImageKHR returns VK_TIMEOUT. If timeout is UINT64_MAX, the timeout period is treated as infinite, and vkAcquireNextImageKHR will block until an image is acquired or an error occurs.

An image will eventually be acquired if the number of images that the application has currently acquired (but not yet presented) is less than or equal to the difference between the number of images in swapchain and the value of VkSurfaceCapabilitiesKHR::minImageCount. If the number of currently acquired images is greater than this, vkAcquireNextImageKHR should not be called; if it is, timeout must not be UINT64_MAX.

If an image is acquired successfully, vkAcquireNextImageKHR must either return VK_SUCCESS, or VK_SUBOPTIMAL_KHR if the swapchain no longer matches the surface properties exactly, but can still be used for presentation.

Note

This may happen, for example, if the platform surface has been resized but the platform is able to scale the presented images to the new size to produce valid surface updates. It is up to the application to decide whether it prefers to continue using the current swapchain in this state, or to re-create the swapchain to better match the platform surface properties.

If the swapchain images no longer match native surface properties, either VK_SUBOPTIMAL_KHR or VK_ERROR_OUT_OF_DATE_KHR must be returned. If VK_ERROR_OUT_OF_DATE_KHR is returned, no image is acquired and attempts to present previously acquired images to the swapchain will also fail with VK_ERROR_OUT_OF_DATE_KHR. Applications need to create a new swapchain for the surface to continue presenting if VK_ERROR_OUT_OF_DATE_KHR is returned.

If device loss occurs (see Lost Device) before the timeout has expired, vkAcquireNextImageKHR must return in finite time with either one of the allowed success codes, or VK_ERROR_DEVICE_LOST.

If semaphore is not VK_NULL_HANDLE, the semaphore must be unsignaled, with no signal or wait operations pending. It will become signaled when the application can use the image.

Note

Use of semaphore allows rendering operations to be recorded and submitted before the presentation engine has completed its use of the image.

If fence is not equal to VK_NULL_HANDLE, the fence must be unsignaled, with no signal operations pending. It will become signaled when the application can use the image.

Note

Applications should not rely on vkAcquireNextImageKHR blocking in order to meter their rendering speed. The implementation may return from this function immediately regardless of how many presentation requests are queued, and regardless of when queued presentation requests will complete relative to the call. Instead, applications can use fence to meter their frame generation work to match the presentation rate.

An application must wait until either the semaphore or fence is signaled before accessing the image’s data.

Note

When the presentable image will be accessed by some stage S, the recommended idiom for ensuring correct synchronization is:

The VkSubmitInfo used to submit the image layout transition for execution includes vkAcquireNextImageKHR::semaphore in its pWaitSemaphores member, with the corresponding element of pWaitDstStageMask including S.
The synchronization command that performs any necessary image layout transition includes S in both the srcStageMask and dstStageMask.

After a successful return, the image indicated by pImageIndex and its data will be unmodified compared to when it was presented.

Note

Exclusive ownership of presentable images corresponding to a swapchain created with VK_SHARING_MODE_EXCLUSIVE as defined in Resource Sharing is not altered by a call to vkAcquireNextImageKHR. That means upon the first acquisition from such a swapchain presentable images are not owned by any queue family, while at subsequent acquisitions the presentable images remain owned by the queue family the image was previously presented on.

The possible return values for vkAcquireNextImageKHR depend on the timeout provided:

VK_SUCCESS is returned if an image became available.
VK_ERROR_SURFACE_LOST_KHR if the surface becomes no longer available.
VK_NOT_READY is returned if timeout is zero and no image was available.
VK_TIMEOUT is returned if timeout is greater than zero and less than UINT64_MAX, and no image became available within the time allowed.
VK_SUBOPTIMAL_KHR is returned if an image became available, and the swapchain no longer matches the surface properties exactly, but can still be used to present to the surface successfully.

Note

This may happen, for example, if the platform surface has been resized but the platform is able to scale the presented images to the new size to produce valid surface updates. It is up to the application to decide whether it prefers to continue using the current swapchain indefinitely or temporarily in this state, or to re-create the swapchain to better match the platform surface properties.

VK_ERROR_OUT_OF_DATE_KHR is returned if the surface has changed in such a way that it is no longer compatible with the swapchain, and further presentation requests using the swapchain will fail. Applications must query the new surface properties and recreate their swapchain if they wish to continue presenting to the surface.

If the native surface and presented image sizes no longer match, presentation may fail. If presentation does succeed, the mapping from the presented image to the native surface is implementation-defined. It is the application’s responsibility to detect surface size changes and react appropriately. If presentation fails because of a mismatch in the surface and presented image sizes, a VK_ERROR_OUT_OF_DATE_KHR error will be returned.

Note

For example, consider a 4x3 window/surface that gets resized to be 3x4 (taller than wider). On some window systems, the portion of the window/surface that was previously and still is visible (the 3x3 part) will contain the same contents as before, while the remaining parts of the window will have undefined contents. Other window systems may squash/stretch the image to fill the new window size without any undefined contents, or apply some other mapping.

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

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

device is the device associated with swapchain.
pAcquireInfo is a pointer to a VkAcquireNextImageInfoKHR structure containing parameters of the acquire.
pImageIndex is a pointer to a uint32_t that is set to the index of the next image to use.

Valid Usage

VUID-vkAcquireNextImage2KHR-swapchain-01803
If the number of currently acquired images is greater than the difference between the number of images in the swapchain member of pAcquireInfo and the value of VkSurfaceCapabilitiesKHR::minImageCount as returned by a call to vkGetPhysicalDeviceSurfaceCapabilities2KHR with the surface used to create swapchain, the timeout member of pAcquireInfo must not be UINT64_MAX

Valid Usage (Implicit)

VUID-vkAcquireNextImage2KHR-device-parameter
device must be a valid VkDevice handle
VUID-vkAcquireNextImage2KHR-pAcquireInfo-parameter
pAcquireInfo must be a valid pointer to a valid VkAcquireNextImageInfoKHR structure
VUID-vkAcquireNextImage2KHR-pImageIndex-parameter
pImageIndex must be a valid pointer to a uint32_t value

Return Codes

VK_SUCCESS
VK_TIMEOUT
VK_NOT_READY
VK_SUBOPTIMAL_KHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST
VK_ERROR_OUT_OF_DATE_KHR
VK_ERROR_SURFACE_LOST_KHR
VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT

The VkAcquireNextImageInfoKHR structure is defined as:

typedef struct VkAcquireNextImageInfoKHR {
    VkStructureType    sType;
    const void*        pNext;
    VkSwapchainKHR     swapchain;
    uint64_t           timeout;
    VkSemaphore        semaphore;
    VkFence            fence;
    uint32_t           deviceMask;
} VkAcquireNextImageInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
swapchain is a non-retired swapchain from which an image is acquired.
timeout specifies how long the function waits, in nanoseconds, if no image is available.
semaphore is VK_NULL_HANDLE or a semaphore to signal.
fence is VK_NULL_HANDLE or a fence to signal.
deviceMask is a mask of physical devices for which the swapchain image will be ready to use when the semaphore or fence is signaled.

If vkAcquireNextImageKHR is used, the device mask is considered to include all physical devices in the logical device.

Note

vkAcquireNextImage2KHR signals at most one semaphore, even if the application requests waiting for multiple physical devices to be ready via the deviceMask. However, only a single physical device can wait on that semaphore, since the semaphore becomes unsignaled when the wait succeeds. For other physical devices to wait for the image to be ready, it is necessary for the application to submit semaphore signal operation(s) to that first physical device to signal additional semaphore(s) after the wait succeeds, which the other physical device(s) can wait upon.

Valid Usage

VUID-VkAcquireNextImageInfoKHR-swapchain-01675
swapchain must not be in the retired state
VUID-VkAcquireNextImageInfoKHR-semaphore-01288
If semaphore is not VK_NULL_HANDLE it must be unsignaled
VUID-VkAcquireNextImageInfoKHR-semaphore-01781
If semaphore is not VK_NULL_HANDLE it must not have any uncompleted signal or wait operations pending
VUID-VkAcquireNextImageInfoKHR-fence-01289
If fence is not VK_NULL_HANDLE it must be unsignaled and must not be associated with any other queue command that has not yet completed execution on that queue
VUID-VkAcquireNextImageInfoKHR-semaphore-01782
semaphore and fence must not both be equal to VK_NULL_HANDLE
VUID-VkAcquireNextImageInfoKHR-deviceMask-01290
deviceMask must be a valid device mask
VUID-VkAcquireNextImageInfoKHR-deviceMask-01291
deviceMask must not be zero
VUID-VkAcquireNextImageInfoKHR-semaphore-03266
semaphore must have a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY

Valid Usage (Implicit)

VUID-VkAcquireNextImageInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR
VUID-VkAcquireNextImageInfoKHR-pNext-pNext
pNext must be NULL
VUID-VkAcquireNextImageInfoKHR-swapchain-parameter
swapchain must be a valid VkSwapchainKHR handle
VUID-VkAcquireNextImageInfoKHR-semaphore-parameter
If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle
VUID-VkAcquireNextImageInfoKHR-fence-parameter
If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle
VUID-VkAcquireNextImageInfoKHR-commonparent
Each of fence, semaphore, and swapchain that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkInstance

Host Synchronization

Host access to swapchain must be externally synchronized
Host access to semaphore must be externally synchronized
Host access to fence must be externally synchronized

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

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

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

Note

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

Valid Usage

VUID-vkQueuePresentKHR-pSwapchains-01292
Each element of pSwapchains member of pPresentInfo must be a swapchain that is created for a surface for which presentation is supported from queue as determined using a call to vkGetPhysicalDeviceSurfaceSupportKHR
VUID-vkQueuePresentKHR-pSwapchains-01293
If more than one member of pSwapchains was created from a display surface, all display surfaces referenced that refer to the same display must use the same display mode
VUID-vkQueuePresentKHR-pWaitSemaphores-01294
When a semaphore wait operation referring to a binary semaphore defined by the elements of the pWaitSemaphores member of pPresentInfo executes on queue, there must be no other queues waiting on the same semaphore.
VUID-vkQueuePresentKHR-pWaitSemaphores-01295
All elements of the pWaitSemaphores member of pPresentInfo must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution.
VUID-vkQueuePresentKHR-pWaitSemaphores-03267
All elements of the pWaitSemaphores member of pPresentInfo must be created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY.
VUID-vkQueuePresentKHR-pWaitSemaphores-03268
All elements of the pWaitSemaphores member of pPresentInfo must reference a semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) must have also been submitted for execution.

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

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

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

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

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

If any swapchain member of pPresentInfo was created with VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT, VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT will be returned if that swapchain does not have exclusive full-screen access, possibly for implementation-specific reasons outside of the application’s control.

Valid Usage (Implicit)

VUID-vkQueuePresentKHR-queue-parameter
queue must be a valid VkQueue handle
VUID-vkQueuePresentKHR-pPresentInfo-parameter
pPresentInfo must be a valid pointer to a valid VkPresentInfoKHR structure

Host Synchronization

Host access to queue must be externally synchronized
Host access to pPresentInfo.pWaitSemaphores[] must be externally synchronized
Host access to pPresentInfo.pSwapchains[] must be externally synchronized

Command Properties

Any

Return Codes

VK_SUCCESS
VK_SUBOPTIMAL_KHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST
VK_ERROR_OUT_OF_DATE_KHR
VK_ERROR_SURFACE_LOST_KHR
VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT

The VkPresentInfoKHR structure is defined as:

typedef struct VkPresentInfoKHR {
    VkStructureType          sType;
    const void*              pNext;
    uint32_t                 waitSemaphoreCount;
    const VkSemaphore*       pWaitSemaphores;
    uint32_t                 swapchainCount;
    const VkSwapchainKHR*    pSwapchains;
    const uint32_t*          pImageIndices;
    VkResult*                pResults;
} VkPresentInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
waitSemaphoreCount is the number of semaphores to wait for before issuing the present request. The number may be zero.
pWaitSemaphores is NULL or a pointer to an array of VkSemaphore objects with waitSemaphoreCount entries, and specifies the semaphores to wait for before issuing the present request.
swapchainCount is the number of swapchains being presented to by this command.
pSwapchains is a pointer to an array of VkSwapchainKHR objects with swapchainCount entries. A given swapchain must not appear in this list more than once.
pImageIndices is a pointer to an array of indices into the array of each swapchain’s presentable images, with swapchainCount entries. Each entry in this array identifies the image to present on the corresponding entry in the pSwapchains array.
pResults is a pointer to an array of VkResult typed elements with swapchainCount entries. Applications that do not need per-swapchain results can use NULL for pResults. If non-NULL, each entry in pResults will be set to the VkResult for presenting the swapchain corresponding to the same index in pSwapchains.

Before an application can present an image, the image’s layout must be transitioned to the VK_IMAGE_LAYOUT_PRESENT_SRC_KHR layout, or for a shared presentable image the VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR layout.

Note

When transitioning the image to VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR or VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, there is no need to delay subsequent processing, or perform any visibility operations (as vkQueuePresentKHR performs automatic visibility operations). To achieve this, the dstAccessMask member of the VkImageMemoryBarrier should be set to 0, and the dstStageMask parameter should be set to VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT.

Valid Usage

VUID-VkPresentInfoKHR-pImageIndices-01430
Each element of pImageIndices must be the index of a presentable image acquired from the swapchain specified by the corresponding element of the pSwapchains array, and the presented image subresource must be in the VK_IMAGE_LAYOUT_PRESENT_SRC_KHR or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR layout at the time the operation is executed on a VkDevice
VUID-VkPresentInfoKHR-pWaitSemaphores-03269
All elements of the pWaitSemaphores must have a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY

Valid Usage (Implicit)

VUID-VkPresentInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_PRESENT_INFO_KHR
VUID-VkPresentInfoKHR-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupPresentInfoKHR, VkDisplayPresentInfoKHR, VkPresentFrameTokenGGP, VkPresentRegionsKHR, or VkPresentTimesInfoGOOGLE
VUID-VkPresentInfoKHR-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkPresentInfoKHR-pWaitSemaphores-parameter
If waitSemaphoreCount is not 0, pWaitSemaphores must be a valid pointer to an array of waitSemaphoreCount valid VkSemaphore handles
VUID-VkPresentInfoKHR-pSwapchains-parameter
pSwapchains must be a valid pointer to an array of swapchainCount valid VkSwapchainKHR handles
VUID-VkPresentInfoKHR-pImageIndices-parameter
pImageIndices must be a valid pointer to an array of swapchainCount uint32_t values
VUID-VkPresentInfoKHR-pResults-parameter
If pResults is not NULL, pResults must be a valid pointer to an array of swapchainCount VkResult values
VUID-VkPresentInfoKHR-swapchainCount-arraylength
swapchainCount must be greater than 0
VUID-VkPresentInfoKHR-commonparent
Both of the elements of pSwapchains, and the elements of pWaitSemaphores that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkInstance

When the VK_KHR_incremental_present extension is enabled, additional fields can be specified that allow an application to specify that only certain rectangular regions of the presentable images of a swapchain are changed. This is an optimization hint that a presentation engine may use to only update the region of a surface that is actually changing. The application still must ensure that all pixels of a presented image contain the desired values, in case the presentation engine ignores this hint. An application can provide this hint by adding a VkPresentRegionsKHR structure to the pNext chain of the VkPresentInfoKHR structure.

The VkPresentRegionsKHR structure is defined as:

typedef struct VkPresentRegionsKHR {
    VkStructureType              sType;
    const void*                  pNext;
    uint32_t                     swapchainCount;
    const VkPresentRegionKHR*    pRegions;
} VkPresentRegionsKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
swapchainCount is the number of swapchains being presented to by this command.
pRegions is NULL or a pointer to an array of VkPresentRegionKHR elements with swapchainCount entries. If not NULL, each element of pRegions contains the region that has changed since the last present to the swapchain in the corresponding entry in the VkPresentInfoKHR::pSwapchains array.

Valid Usage

VUID-VkPresentRegionsKHR-swapchainCount-01260
swapchainCount must be the same value as VkPresentInfoKHR::swapchainCount, where VkPresentInfoKHR is included in the pNext chain of this VkPresentRegionsKHR structure

Valid Usage (Implicit)

VUID-VkPresentRegionsKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR
VUID-VkPresentRegionsKHR-pRegions-parameter
If pRegions is not NULL, pRegions must be a valid pointer to an array of swapchainCount valid VkPresentRegionKHR structures
VUID-VkPresentRegionsKHR-swapchainCount-arraylength
swapchainCount must be greater than 0

For a given image and swapchain, the region to present is specified by the VkPresentRegionKHR structure, which is defined as:

typedef struct VkPresentRegionKHR {
    uint32_t                 rectangleCount;
    const VkRectLayerKHR*    pRectangles;
} VkPresentRegionKHR;

rectangleCount is the number of rectangles in pRectangles, or zero if the entire image has changed and should be presented.
pRectangles is either NULL or a pointer to an array of VkRectLayerKHR structures. The VkRectLayerKHR structure is the framebuffer coordinates, plus layer, of a portion of a presentable image that has changed and must be presented. If non-NULL, each entry in pRectangles is a rectangle of the given image that has changed since the last image was presented to the given swapchain.

Valid Usage (Implicit)

VUID-VkPresentRegionKHR-pRectangles-parameter
If rectangleCount is not 0, and pRectangles is not NULL, pRectangles must be a valid pointer to an array of rectangleCount valid VkRectLayerKHR structures

The VkRectLayerKHR structure is defined as:

typedef struct VkRectLayerKHR {
    VkOffset2D    offset;
    VkExtent2D    extent;
    uint32_t      layer;
} VkRectLayerKHR;

offset is the origin of the rectangle, in pixels.
extent is the size of the rectangle, in pixels.
layer is the layer of the image. For images with only one layer, the value of layer must be 0.

Valid Usage

VUID-VkRectLayerKHR-offset-01261
The sum of offset and extent must be no greater than the imageExtent member of the VkSwapchainCreateInfoKHR structure given to vkCreateSwapchainKHR.
VUID-VkRectLayerKHR-layer-01262
layer must be less than imageArrayLayers member of the VkSwapchainCreateInfoKHR structure given to vkCreateSwapchainKHR.

Some platforms allow the size of a surface to change, and then scale the pixels of the image to fit the surface. VkRectLayerKHR specifies pixels of the swapchain’s image(s), which will be constant for the life of the swapchain.

When the VK_KHR_display_swapchain extension is enabled additional fields can be specified when presenting an image to a swapchain by setting VkPresentInfoKHR::pNext to point to a VkDisplayPresentInfoKHR structure.

The VkDisplayPresentInfoKHR structure is defined as:

typedef struct VkDisplayPresentInfoKHR {
    VkStructureType    sType;
    const void*        pNext;
    VkRect2D           srcRect;
    VkRect2D           dstRect;
    VkBool32           persistent;
} VkDisplayPresentInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
srcRect is a rectangular region of pixels to present. It must be a subset of the image being presented. If VkDisplayPresentInfoKHR is not specified, this region will be assumed to be the entire presentable image.
dstRect is a rectangular region within the visible region of the swapchain’s display mode. If VkDisplayPresentInfoKHR is not specified, this region will be assumed to be the entire visible region of the visible region of the swapchain’s mode. If the specified rectangle is a subset of the display mode’s visible region, content from display planes below the swapchain’s plane will be visible outside the rectangle. If there are no planes below the swapchain’s, the area outside the specified rectangle will be black. If portions of the specified rectangle are outside of the display’s visible region, pixels mapping only to those portions of the rectangle will be discarded.
persistent: If this is VK_TRUE, the display engine will enable buffered mode on displays that support it. This allows the display engine to stop sending content to the display until a new image is presented. The display will instead maintain a copy of the last presented image. This allows less power to be used, but may increase presentation latency. If VkDisplayPresentInfoKHR is not specified, persistent mode will not be used.

If the extent of the srcRect and dstRect are not equal, the presented pixels will be scaled accordingly.

Valid Usage

VUID-VkDisplayPresentInfoKHR-srcRect-01257
srcRect must specify a rectangular region that is a subset of the image being presented
VUID-VkDisplayPresentInfoKHR-dstRect-01258
dstRect must specify a rectangular region that is a subset of the visibleRegion parameter of the display mode the swapchain being presented uses
VUID-VkDisplayPresentInfoKHR-persistentContent-01259
If the persistentContent member of the VkDisplayPropertiesKHR structure returned by vkGetPhysicalDeviceDisplayPropertiesKHR for the display the present operation targets then persistent must be VK_FALSE

Valid Usage (Implicit)

VUID-VkDisplayPresentInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR

If the pNext chain of VkPresentInfoKHR includes a VkDeviceGroupPresentInfoKHR structure, then that structure includes an array of device masks and a device group present mode.

The VkDeviceGroupPresentInfoKHR structure is defined as:

typedef struct VkDeviceGroupPresentInfoKHR {
    VkStructureType                        sType;
    const void*                            pNext;
    uint32_t                               swapchainCount;
    const uint32_t*                        pDeviceMasks;
    VkDeviceGroupPresentModeFlagBitsKHR    mode;
} VkDeviceGroupPresentInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
swapchainCount is zero or the number of elements in pDeviceMasks.
pDeviceMasks is a pointer to an array of device masks, one for each element of VkPresentInfoKHR::pSwapchains.
mode is the device group present mode that will be used for this present.

If mode is VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR, then each element of pDeviceMasks selects which instance of the swapchain image is presented. Each element of pDeviceMasks must have exactly one bit set, and the corresponding physical device must have a presentation engine as reported by VkDeviceGroupPresentCapabilitiesKHR.

If mode is VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR, then each element of pDeviceMasks selects which instance of the swapchain image is presented. Each element of pDeviceMasks must have exactly one bit set, and some physical device in the logical device must include that bit in its VkDeviceGroupPresentCapabilitiesKHR::presentMask.

If mode is VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR, then each element of pDeviceMasks selects which instances of the swapchain image are component-wise summed and the sum of those images is presented. If the sum in any component is outside the representable range, the value of that component is undefined. Each element of pDeviceMasks must have a value for which all set bits are set in one of the elements of VkDeviceGroupPresentCapabilitiesKHR::presentMask.

If mode is VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR, then each element of pDeviceMasks selects which instance(s) of the swapchain images are presented. For each bit set in each element of pDeviceMasks, the corresponding physical device must have a presentation engine as reported by VkDeviceGroupPresentCapabilitiesKHR.

If VkDeviceGroupPresentInfoKHR is not provided or swapchainCount is zero then the masks are considered to be 1. If VkDeviceGroupPresentInfoKHR is not provided, mode is considered to be VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR.

Valid Usage

VUID-VkDeviceGroupPresentInfoKHR-swapchainCount-01297
swapchainCount must equal 0 or VkPresentInfoKHR::swapchainCount
VUID-VkDeviceGroupPresentInfoKHR-mode-01298
If mode is VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR, then each element of pDeviceMasks must have exactly one bit set, and the corresponding element of VkDeviceGroupPresentCapabilitiesKHR::presentMask must be non-zero
VUID-VkDeviceGroupPresentInfoKHR-mode-01299
If mode is VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR, then each element of pDeviceMasks must have exactly one bit set, and some physical device in the logical device must include that bit in its VkDeviceGroupPresentCapabilitiesKHR::presentMask.
VUID-VkDeviceGroupPresentInfoKHR-mode-01300
If mode is VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR, then each element of pDeviceMasks must have a value for which all set bits are set in one of the elements of VkDeviceGroupPresentCapabilitiesKHR::presentMask
VUID-VkDeviceGroupPresentInfoKHR-mode-01301
If mode is VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR, then for each bit set in each element of pDeviceMasks, the corresponding element of VkDeviceGroupPresentCapabilitiesKHR::presentMask must be non-zero
VUID-VkDeviceGroupPresentInfoKHR-pDeviceMasks-01302
The value of each element of pDeviceMasks must be equal to the device mask passed in VkAcquireNextImageInfoKHR::deviceMask when the image index was last acquired
VUID-VkDeviceGroupPresentInfoKHR-mode-01303
mode must have exactly one bit set, and that bit must have been included in VkDeviceGroupSwapchainCreateInfoKHR::modes

Valid Usage (Implicit)

VUID-VkDeviceGroupPresentInfoKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR
VUID-VkDeviceGroupPresentInfoKHR-pDeviceMasks-parameter
If swapchainCount is not 0, pDeviceMasks must be a valid pointer to an array of swapchainCount uint32_t values
VUID-VkDeviceGroupPresentInfoKHR-mode-parameter
mode must be a valid VkDeviceGroupPresentModeFlagBitsKHR value

When the VK_GOOGLE_display_timing extension is enabled, additional fields can be specified that allow an application to specify the earliest time that an image should be displayed. This allows an application to avoid stutter that is caused by an image being displayed earlier than planned. Such stuttering can occur with both fixed and variable-refresh-rate displays, because stuttering occurs when the geometry is not correctly positioned for when the image is displayed. An application can instruct the presentation engine that an image should not be displayed earlier than a specified time by adding a VkPresentTimesInfoGOOGLE structure to the pNext chain of the VkPresentInfoKHR structure.

The VkPresentTimesInfoGOOGLE structure is defined as:

typedef struct VkPresentTimesInfoGOOGLE {
    VkStructureType               sType;
    const void*                   pNext;
    uint32_t                      swapchainCount;
    const VkPresentTimeGOOGLE*    pTimes;
} VkPresentTimesInfoGOOGLE;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
swapchainCount is the number of swapchains being presented to by this command.
pTimes is NULL or a pointer to an array of VkPresentTimeGOOGLE elements with swapchainCount entries. If not NULL, each element of pTimes contains the earliest time to present the image corresponding to the entry in the VkPresentInfoKHR::pImageIndices array.

Valid Usage

VUID-VkPresentTimesInfoGOOGLE-swapchainCount-01247
swapchainCount must be the same value as VkPresentInfoKHR::swapchainCount, where VkPresentInfoKHR is included in the pNext chain of this VkPresentTimesInfoGOOGLE structure.

Valid Usage (Implicit)

VUID-VkPresentTimesInfoGOOGLE-sType-sType
sType must be VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE
VUID-VkPresentTimesInfoGOOGLE-pTimes-parameter
If pTimes is not NULL, pTimes must be a valid pointer to an array of swapchainCount VkPresentTimeGOOGLE structures
VUID-VkPresentTimesInfoGOOGLE-swapchainCount-arraylength
swapchainCount must be greater than 0

The VkPresentTimeGOOGLE structure is defined as:

typedef struct VkPresentTimeGOOGLE {
    uint32_t    presentID;
    uint64_t    desiredPresentTime;
} VkPresentTimeGOOGLE;

presentID is an application-provided identification value, that can be used with the results of vkGetPastPresentationTimingGOOGLE, in order to uniquely identify this present. In order to be useful to the application, it should be unique within some period of time that is meaningful to the application.
desiredPresentTime specifies that the image given should not be displayed to the user any earlier than this time. desiredPresentTime is a time in nanoseconds, relative to a monotonically-increasing clock (e.g. CLOCK_MONOTONIC (see clock_gettime(2)) on Android and Linux). A value of zero specifies that the presentation engine may display the image at any time. This is useful when the application desires to provide presentID, but does not need a specific desiredPresentTime.

When the VK_GGP_frame_token extension is enabled, a Google Games Platform frame token can be specified when presenting an image to a swapchain by adding a VkPresentFrameTokenGGP structure to the pNext chain of the VkPresentInfoKHR structure.

The VkPresentFrameTokenGGP structure is defined as:

typedef struct VkPresentFrameTokenGGP {
    VkStructureType    sType;
    const void*        pNext;
    GgpFrameToken      frameToken;
} VkPresentFrameTokenGGP;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
frameToken is the Google Games Platform frame token.

Valid Usage

VUID-VkPresentFrameTokenGGP-frameToken-02680
frameToken must be a valid GgpFrameToken

Valid Usage (Implicit)

VUID-VkPresentFrameTokenGGP-sType-sType
sType must be VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP

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

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

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

The result codes VK_ERROR_OUT_OF_DATE_KHR and VK_SUBOPTIMAL_KHR have the same meaning when returned by vkQueuePresentKHR as they do when returned by vkAcquireNextImageKHR. If multiple swapchains are presented, the result code is determined applying the following rules in order:

If the device is lost, VK_ERROR_DEVICE_LOST is returned.
If any of the target surfaces are no longer available the error VK_ERROR_SURFACE_LOST_KHR is returned.
If any of the presents would have a result of VK_ERROR_OUT_OF_DATE_KHR if issued separately then VK_ERROR_OUT_OF_DATE_KHR is returned.
If any of the presents would have a result of VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT if issued separately then VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT is returned.
If any of the presents would have a result of VK_SUBOPTIMAL_KHR if issued separately then VK_SUBOPTIMAL_KHR is returned.
Otherwise VK_SUCCESS is returned.

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

Note

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

32.10. Hdr Metadata

To improve color reproduction of content it is useful to have information that can be used to better reproduce the colors as seen on the mastering display. That information can be provided to an implementation by calling vkSetHdrMetadataEXT. The metadata will be applied to the specified VkSwapchainKHR objects at the next vkQueuePresentKHR call using that VkSwapchainKHR object. The metadata will persist until a subsequent vkSetHdrMetadataEXT changes it. The definitions below are from the associated SMPTE 2086, CTA 861.3 and CIE 15:2004 specifications.

The definition of vkSetHdrMetadataEXT is:

void vkSetHdrMetadataEXT(
    VkDevice                                    device,
    uint32_t                                    swapchainCount,
    const VkSwapchainKHR*                       pSwapchains,
    const VkHdrMetadataEXT*                     pMetadata);

device is the logical device where the swapchain(s) were created.
swapchainCount is the number of swapchains included in pSwapchains.
pSwapchains is a pointer to an array of swapchainCount VkSwapchainKHR handles.
pMetadata is a pointer to an array of swapchainCount VkHdrMetadataEXT structures.

Valid Usage (Implicit)

VUID-vkSetHdrMetadataEXT-device-parameter
device must be a valid VkDevice handle
VUID-vkSetHdrMetadataEXT-pSwapchains-parameter
pSwapchains must be a valid pointer to an array of swapchainCount valid VkSwapchainKHR handles
VUID-vkSetHdrMetadataEXT-pMetadata-parameter
pMetadata must be a valid pointer to an array of swapchainCount valid VkHdrMetadataEXT structures
VUID-vkSetHdrMetadataEXT-swapchainCount-arraylength
swapchainCount must be greater than 0
VUID-vkSetHdrMetadataEXT-commonparent
Both of device, and the elements of pSwapchains must have been created, allocated, or retrieved from the same VkInstance

typedef struct VkXYColorEXT {
    float    x;
    float    y;
} VkXYColorEXT;

Chromaticity coordinates x and y are as specified in CIE 15:2004 “Calculation of chromaticity coordinates” (Section 7.3) and are limited to between 0 and 1 for real colors for the mastering display.

typedef struct VkHdrMetadataEXT {
    VkStructureType    sType;
    const void*        pNext;
    VkXYColorEXT       displayPrimaryRed;
    VkXYColorEXT       displayPrimaryGreen;
    VkXYColorEXT       displayPrimaryBlue;
    VkXYColorEXT       whitePoint;
    float              maxLuminance;
    float              minLuminance;
    float              maxContentLightLevel;
    float              maxFrameAverageLightLevel;
} VkHdrMetadataEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
displayPrimaryRed is the mastering display’s red primary in chromaticity coordinates
displayPrimaryGreen is the mastering display’s green primary in chromaticity coordinates
displayPrimaryBlue is the mastering display’s blue primary in chromaticity coordinates
whitePoint is the mastering display’s white-point in chromaticity coordinates
maxLuminance is the maximum luminance of the mastering display in nits
minLuminance is the minimum luminance of the mastering display in nits
maxContentLightLevel is content’s maximum luminance in nits
maxFrameAverageLightLevel is the maximum frame average light level in nits

Valid Usage (Implicit)

VUID-VkHdrMetadataEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_HDR_METADATA_EXT
VUID-VkHdrMetadataEXT-pNext-pNext
pNext must be NULL

Note

The validity and use of this data is outside the scope of Vulkan.

33. Ray Tracing

Unlike draw commands, which use rasterization, ray tracing is a rendering method that generates an image by tracing the path of rays which have a single origin and using shaders to determine the final colour of an image plane.

Ray tracing uses a separate rendering pipeline from both the graphics and compute pipelines (see Ray tracing Pipeline). It has a unique set of programmable and fixed function stages.

Figure 24. Ray tracing Pipeline

Caption

Interaction between the different shader stages in the ray tracing pipeline

33.1. Ray Tracing Commands

Ray tracing commands provoke work in the ray tracing pipeline. Ray tracing commands are recorded into a command buffer and when executed by a queue will produce work that executes according to the currently bound ray tracing pipeline. A ray tracing pipeline must be bound to a command buffer before any ray tracing commands are recorded in that command buffer.

Each ray tracing call operates on a set of shader stages that are specific to the ray tracing pipeline as well as a set of VkAccelerationStructureNV objects describing the scene geometry in an implementation-specific way. The relationship between the ray tracing pipeline object and the acceleration structures is passed into the ray tracing command in a VkBuffer object known as a shader binding table.

During execution, control alternates between scheduling and other operations. The scheduling functionality is implementation-specific and is responsible for workload execution. The shader stages are programmable. Traversal, which refers to the process of traversing acceleration structures to find potential intersections of rays with geometry, is fixed function.

The programmable portions of the pipeline are exposed in a single-ray programming model. Each GPU thread handles one ray at a time. Memory operations can be synchronized using standard memory barriers. However, communication and synchronization between threads is not allowed. In particular, the use of compute pipeline synchronization functions is not supported in the ray tracing pipeline.

To dispatch a ray tracing call use:

void vkCmdTraceRaysNV(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    raygenShaderBindingTableBuffer,
    VkDeviceSize                                raygenShaderBindingOffset,
    VkBuffer                                    missShaderBindingTableBuffer,
    VkDeviceSize                                missShaderBindingOffset,
    VkDeviceSize                                missShaderBindingStride,
    VkBuffer                                    hitShaderBindingTableBuffer,
    VkDeviceSize                                hitShaderBindingOffset,
    VkDeviceSize                                hitShaderBindingStride,
    VkBuffer                                    callableShaderBindingTableBuffer,
    VkDeviceSize                                callableShaderBindingOffset,
    VkDeviceSize                                callableShaderBindingStride,
    uint32_t                                    width,
    uint32_t                                    height,
    uint32_t                                    depth);

commandBuffer is the command buffer into which the command will be recorded.
raygenShaderBindingTableBuffer is the buffer object that holds the shader binding table data for the ray generation shader stage.
raygenShaderBindingOffset is the offset in bytes (relative to raygenShaderBindingTableBuffer) of the ray generation shader being used for the trace.
missShaderBindingTableBuffer is the buffer object that holds the shader binding table data for the miss shader stage.
missShaderBindingOffset is the offset in bytes (relative to missShaderBindingTableBuffer) of the miss shader being used for the trace.
missShaderBindingStride is the size in bytes of each shader binding table record in missShaderBindingTableBuffer.
hitShaderBindingTableBuffer is the buffer object that holds the shader binding table data for the hit shader stages.
hitShaderBindingOffset is the offset in bytes (relative to hitShaderBindingTableBuffer) of the hit shader group being used for the trace.
hitShaderBindingStride is the size in bytes of each shader binding table record in hitShaderBindingTableBuffer.
callableShaderBindingTableBuffer is the buffer object that holds the shader binding table data for the callable shader stage.
callableShaderBindingOffset is the offset in bytes (relative to callableShaderBindingTableBuffer) of the callable shader being used for the trace.
callableShaderBindingStride is the size in bytes of each shader binding table record in callableShaderBindingTableBuffer.
width is the width of the ray trace query dimensions.
height is height of the ray trace query dimensions.
depth is depth of the ray trace query dimensions.

When the command is executed, a ray generation group of width × height × depth rays is assembled.

Valid Usage

VUID-vkCmdTraceRaysNV-None-02690
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
VUID-vkCmdTraceRaysNV-None-02691
If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
VUID-vkCmdTraceRaysNV-None-02692
If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT
VUID-vkCmdTraceRaysNV-filterCubic-02694
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdTraceRaysNV-filterCubicMinmax-02695
Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2
VUID-vkCmdTraceRaysNV-flags-02696
Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE.
VUID-vkCmdTraceRaysNV-None-02697
For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdTraceRaysNV-None-02698
For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
VUID-vkCmdTraceRaysNV-None-02699
Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command
VUID-vkCmdTraceRaysNV-None-02700
A valid pipeline must be bound to the pipeline bind point used by this command
VUID-vkCmdTraceRaysNV-commandBuffer-02701
If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic
VUID-vkCmdTraceRaysNV-None-02859
There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound
VUID-vkCmdTraceRaysNV-None-02702
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
VUID-vkCmdTraceRaysNV-None-02703
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdTraceRaysNV-None-02704
If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler 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
VUID-vkCmdTraceRaysNV-None-02705
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdTraceRaysNV-None-02706
If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
VUID-vkCmdTraceRaysNV-commandBuffer-02707
If commandBuffer is an unprotected command buffer, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource
VUID-vkCmdTraceRaysNV-commandBuffer-02712
If commandBuffer is a protected command buffer, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource
VUID-vkCmdTraceRaysNV-commandBuffer-02713
If commandBuffer is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the VkPipeline object bound to the pipeline bind point must not write to any resource
VUID-vkCmdTraceRaysNV-raygenShaderBindingOffset-02455
raygenShaderBindingOffset must be less than the size of raygenShaderBindingTableBuffer
VUID-vkCmdTraceRaysNV-raygenShaderBindingOffset-02456
raygenShaderBindingOffset must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupBaseAlignment
VUID-vkCmdTraceRaysNV-missShaderBindingOffset-02457
missShaderBindingOffset must be less than the size of missShaderBindingTableBuffer
VUID-vkCmdTraceRaysNV-missShaderBindingOffset-02458
missShaderBindingOffset must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupBaseAlignment
VUID-vkCmdTraceRaysNV-hitShaderBindingOffset-02459
hitShaderBindingOffset must be less than the size of hitShaderBindingTableBuffer
VUID-vkCmdTraceRaysNV-hitShaderBindingOffset-02460
hitShaderBindingOffset must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupBaseAlignment
VUID-vkCmdTraceRaysNV-callableShaderBindingOffset-02461
callableShaderBindingOffset must be less than the size of callableShaderBindingTableBuffer
VUID-vkCmdTraceRaysNV-callableShaderBindingOffset-02462
callableShaderBindingOffset must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupBaseAlignment
VUID-vkCmdTraceRaysNV-missShaderBindingStride-02463
missShaderBindingStride must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupHandleSize
VUID-vkCmdTraceRaysNV-hitShaderBindingStride-02464
hitShaderBindingStride must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupHandleSize
VUID-vkCmdTraceRaysNV-callableShaderBindingStride-02465
callableShaderBindingStride must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupHandleSize
VUID-vkCmdTraceRaysNV-missShaderBindingStride-02466
missShaderBindingStride must be a less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxShaderGroupStride
VUID-vkCmdTraceRaysNV-hitShaderBindingStride-02467
hitShaderBindingStride must be a less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxShaderGroupStride
VUID-vkCmdTraceRaysNV-callableShaderBindingStride-02468
callableShaderBindingStride must be a less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxShaderGroupStride
VUID-vkCmdTraceRaysNV-width-02469
width must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]
VUID-vkCmdTraceRaysNV-height-02470
height must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]
VUID-vkCmdTraceRaysNV-depth-02471
depth must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]

Valid Usage (Implicit)

VUID-vkCmdTraceRaysNV-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdTraceRaysNV-raygenShaderBindingTableBuffer-parameter
raygenShaderBindingTableBuffer must be a valid VkBuffer handle
VUID-vkCmdTraceRaysNV-missShaderBindingTableBuffer-parameter
If missShaderBindingTableBuffer is not VK_NULL_HANDLE, missShaderBindingTableBuffer must be a valid VkBuffer handle
VUID-vkCmdTraceRaysNV-hitShaderBindingTableBuffer-parameter
If hitShaderBindingTableBuffer is not VK_NULL_HANDLE, hitShaderBindingTableBuffer must be a valid VkBuffer handle
VUID-vkCmdTraceRaysNV-callableShaderBindingTableBuffer-parameter
If callableShaderBindingTableBuffer is not VK_NULL_HANDLE, callableShaderBindingTableBuffer must be a valid VkBuffer handle
VUID-vkCmdTraceRaysNV-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdTraceRaysNV-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support compute operations
VUID-vkCmdTraceRaysNV-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdTraceRaysNV-commonparent
Each of callableShaderBindingTableBuffer, commandBuffer, hitShaderBindingTableBuffer, missShaderBindingTableBuffer, and raygenShaderBindingTableBuffer that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Compute

33.2. Shader Binding Table

A shader binding table is a resource which establishes the relationship between the ray tracing pipeline and the acceleration structures that were built for the ray tracing query. It indicates the shaders that operate on each geometry in an acceleration structure. In addition, it contains the resources accessed by each shader, including indices of textures and constants. The application allocates and manages shader binding tables as VkBuffer objects.

Each entry in the shader binding table consists of shaderGroupHandleSize bytes of data as queried by vkGetRayTracingShaderGroupHandlesNV to refer to the shader that it invokes. The remainder of the data specified by the stride is application-visible data that can be referenced by a shaderRecordNV block in the shader.

The shader binding tables to use in a ray tracing query are passed to vkCmdTraceRaysNV. Shader binding tables are read-only in shaders that are executing on the ray tracing pipeline.

33.2.1. Indexing Rules

In order to execute the correct shaders and access the correct resources during a ray tracing dispatch, the implementation must be able to locate shader binding table entries at various stages of execution. This is accomplished by defining a set of indexing rules that compute shader binding table record positions relative to the buffer’s base address in memory. The application must organize the contents of the shader binding table’s memory in a way that application of the indexing rules will lead to correct records.

Ray Generation Shaders

Only one ray generation shader is executed per ray tracing dispatch. Its location is passed into vkCmdTraceRaysNV using the raygenShaderBindingTableBuffer and raygenShaderBindingTableOffset parameters — there is no indexing.

Hit Shaders

The base for the computation of intersection, any-hit and closest hit shader locations is the instanceShaderBindingTableRecordOffset value stored with each instance of a top-level acceleration structure. This value determines the beginning of the shader binding table records for a given instance. Each geometry in the instance must have at least one hit program record.

In the following rule, geometryIndex refers to the location of the geometry within the instance.

The sbtRecordStride and sbtRecordOffset values are passed in as parameters to traceNV() calls made in the shaders. See Section 8.19 (Ray Tracing Functions) of the OpenGL Shading Language Specification for more details. In SPIR-V, these correspond to the SBTOffset and SBTStride parameters to the OpTraceNV instruction.

The result of this computation is then added to hitShaderBindingOffset, a base offset passed to vkCmdTraceRaysNV.

The complete rule to compute a hit shader binding table record address in the hitShaderBindingTableBuffer is:

: hitShaderBindingOffset + hitShaderBindingStride × ( instanceShaderBindingTableRecordOffset + geometryIndex × sbtRecordStride + sbtRecordOffset )

Miss Shaders

A miss shader is executed whenever a ray query fails to find an intersection for the given scene geometry. Multiple miss shaders may be executed throughout a ray tracing dispatch.

The base for the computation of miss shader locations is missShaderBindingOffset, a base offset passed into vkCmdTraceRaysNV.

The missIndex value is passed in as parameters to traceNV() calls made in the shaders. See Section 8.19 (Ray Tracing Functions) of the OpenGL Shading Language Specification for more details. In SPIR-V, this corresponds to the MissIndex parameter to the OpTraceNV instruction.

The complete rule to compute a miss shader binding table record address in the missShaderBindingTableBuffer is:

: missShaderBindingOffset + missShaderBindingStride × missIndex

Callable Shaders

A callable shader is executed when requested by a ray tracing shader. Multiple callable shaders may be executed throughout a ray tracing dispatch.

The base for the computation of callable shader locations is callableShaderBindingOffset, a base offset passed into vkCmdTraceRaysNV.

The sbtRecordIndex value is passed in as a parameter to executeCallableNV() calls made in the shaders. See Section 8.19 (Ray Tracing Functions) of the OpenGL Shading Language Specification for more details. In SPIR-V, this corresponds to the SBTIndex parameter to the OpExecuteCallableNV instruction.

The complete rule to compute a callable shader binding table record address in the callableShaderBindingTableBuffer is:

: callableShaderBindingOffset + callableShaderBindingStride × sbtRecordIndex

33.3. Acceleration Structures

Acceleration structures are data structures used by the implementation to efficiently manage the scene geometry as it is traversed during a ray tracing query. The application is responsible for managing acceleration structure objects (see Acceleration Structures, including allocation, destruction, executing builds or updates, and synchronizing resources used during ray tracing queries.

There are two types of acceleration structures, top level acceleration structures and bottom level acceleration structures.

Figure 25. Acceleration Structure

Caption

The diagram shows the relationship between top and bottom level acceleration structures.

33.3.1. Instances

Instances are found in top level acceleration structures and contain data that refer to a single bottom-level acceleration structure, a transform matrix, and shading information. Multiple instances can point to a single bottom level acceleration structure.

An instance is defined in a VkBuffer by a structure consisting of 64 bytes of data.

transform is 12 floats representing a 4x3 transform matrix in row-major order
instanceCustomIndex The low 24 bits of a 32-bit integer after the transform. This value appears in the builtin gl_InstanceCustomIndexNV
mask The high 8 bits of the same integer as instanceCustomIndex. This is the visibility mask. The instance may only be hit if rayMask & instance.mask != 0
instanceOffset The low 24 bits of the next 32-bit integer. The value contributed by this instance to the hit shader binding table index computation as instanceShaderBindingTableRecordOffset.
flags The high 8 bits of the same integer as instanceOffset. VkGeometryInstanceFlagBitsNV values that apply to this instance.
accelerationStructure. The 8 byte value returned by vkGetAccelerationStructureHandleNV for the bottom level acceleration structure referred to by this instance.

Note

The C language spec does not define the ordering of bit-fields, but in practice, this struct produces the layout described above:

struct VkGeometryInstanceNV {
    float          transform[12];
    uint32_t       instanceCustomIndex : 24;
    uint32_t       mask : 8;
    uint32_t       instanceOffset : 24;
    uint32_t       flags : 8;
    uint64_t       accelerationStructureHandle;
};

Possible values of flags in the instance modifying the behavior of that instance are:,

typedef enum VkGeometryInstanceFlagBitsNV {
    VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = 0x00000001,
    VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = 0x00000002,
    VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = 0x00000004,
    VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = 0x00000008,
    VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
} VkGeometryInstanceFlagBitsNV;

VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV disables face culling for this instance.
VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV indicates that the front face of the triangle for culling purposes is the face that is counter clockwise in object space relative to the ray origin. Because the facing is determined in object space, an instance transform matrix does not change the winding, but a geometry transform does.
VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV causes this instance to act as though VK_GEOMETRY_OPAQUE_BIT_NV were specified on all geometries referenced by this instance. This behavior can be overridden by the ray flag gl_RayFlagsNoOpaqueNV.
VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV causes this instance to act as though VK_GEOMETRY_OPAQUE_BIT_NV were not specified on all geometries referenced by this instance. This behavior can be overridden by the ray flag gl_RayFlagsOpaqueNV.

VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV and VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV must not be used in the same flag.

typedef VkFlags VkGeometryInstanceFlagsNV;

VkGeometryInstanceFlagsNV is a bitmask type for setting a mask of zero or more VkGeometryInstanceFlagBitsNV.

33.3.2. Geometry

Geometries refer to a triangle or axis-aligned bounding box.

33.3.3. Top Level Acceleration Structures

Opaque acceleration structure for an array of instances. The descriptor referencing this is the starting point for tracing

33.3.4. Bottom Level Acceleration Structures

Opaque acceleration structure for an array of geometries.

33.3.5. Building Acceleration Structures

To build an acceleration structure call:

void vkCmdBuildAccelerationStructureNV(
    VkCommandBuffer                             commandBuffer,
    const VkAccelerationStructureInfoNV*        pInfo,
    VkBuffer                                    instanceData,
    VkDeviceSize                                instanceOffset,
    VkBool32                                    update,
    VkAccelerationStructureNV                   dst,
    VkAccelerationStructureNV                   src,
    VkBuffer                                    scratch,
    VkDeviceSize                                scratchOffset);

commandBuffer is the command buffer into which the command will be recorded.
pInfo contains the shared information for the acceleration structure’s structure.
instanceData is the buffer containing instance data that will be used to build the acceleration structure as described in Accelerator structure instances. This parameter must be NULL for bottom level acceleration structures.
instanceOffset is the offset in bytes (relative to the start of instanceData) at which the instance data is located.
update specifies whether to update the dst acceleration structure with the data in src.
dst is a pointer to the target acceleration structure for the build.
src is a pointer to an existing acceleration structure that is to be used to update the dst acceleration structure.
scratch is the VkBuffer that will be used as scratch memory for the build.
scratchOffset is the offset in bytes relative to the start of scratch that will be used as a scratch memory.

Valid Usage

VUID-vkCmdBuildAccelerationStructureNV-geometryCount-02241
geometryCount must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxGeometryCount
VUID-vkCmdBuildAccelerationStructureNV-dst-02488
dst must have been created with compatible VkAccelerationStructureInfoNV where VkAccelerationStructureInfoNV::type and VkAccelerationStructureInfoNV::flags are identical, VkAccelerationStructureInfoNV::instanceCount and VkAccelerationStructureInfoNV::geometryCount for dst are greater than or equal to the build size and each geometry in VkAccelerationStructureInfoNV::pGeometries for dst has greater than or equal to the number of vertices, indices, and AABBs.
VUID-vkCmdBuildAccelerationStructureNV-update-02489
If update is VK_TRUE, src must not be VK_NULL_HANDLE
VUID-vkCmdBuildAccelerationStructureNV-update-02490
If update is VK_TRUE, src must have been built before with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV set in VkAccelerationStructureInfoNV::flags
VUID-vkCmdBuildAccelerationStructureNV-update-02491
If update is VK_FALSE, The size member of the VkMemoryRequirements structure returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with VkAccelerationStructureMemoryRequirementsInfoNV::accelerationStructure set to dst and VkAccelerationStructureMemoryRequirementsInfoNV::type set to VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV must be less than or equal to the size of scratch minus scratchOffset
VUID-vkCmdBuildAccelerationStructureNV-update-02492
If update is VK_TRUE, The size member of the VkMemoryRequirements structure returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with VkAccelerationStructureMemoryRequirementsInfoNV::accelerationStructure set to dst and VkAccelerationStructureMemoryRequirementsInfoNV::type set to VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV must be less than or equal to the size of scratch minus scratchOffset

Valid Usage (Implicit)

VUID-vkCmdBuildAccelerationStructureNV-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdBuildAccelerationStructureNV-pInfo-parameter
pInfo must be a valid pointer to a valid VkAccelerationStructureInfoNV structure
VUID-vkCmdBuildAccelerationStructureNV-instanceData-parameter
If instanceData is not VK_NULL_HANDLE, instanceData must be a valid VkBuffer handle
VUID-vkCmdBuildAccelerationStructureNV-dst-parameter
dst must be a valid VkAccelerationStructureNV handle
VUID-vkCmdBuildAccelerationStructureNV-src-parameter
If src is not VK_NULL_HANDLE, src must be a valid VkAccelerationStructureNV handle
VUID-vkCmdBuildAccelerationStructureNV-scratch-parameter
scratch must be a valid VkBuffer handle
VUID-vkCmdBuildAccelerationStructureNV-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdBuildAccelerationStructureNV-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support compute operations
VUID-vkCmdBuildAccelerationStructureNV-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdBuildAccelerationStructureNV-commonparent
Each of commandBuffer, dst, instanceData, scratch, and src that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Compute

33.3.6. Copying Acceleration Structures

An additional command exists for copying acceleration structures without updating their contents. The acceleration structure object can be compacted in order to improve performance. Before copying, an application must query the size of the resulting acceleration structure.

To query acceleration structure size parameters call:

void vkCmdWriteAccelerationStructuresPropertiesNV(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    accelerationStructureCount,
    const VkAccelerationStructureNV*            pAccelerationStructures,
    VkQueryType                                 queryType,
    VkQueryPool                                 queryPool,
    uint32_t                                    firstQuery);

commandBuffer is the command buffer into which the command will be recorded.
accelerationStructureCount is the count of acceleration structures for which to query the property.
pAccelerationStructures is a pointer to an array of existing previously built acceleration structures.
queryType is a VkQueryType value specifying the type of queries managed by the pool.
queryPool is the query pool that will manage the results of the query.
firstQuery is the first query index within the query pool that will contain the accelerationStructureCount number of results.

Valid Usage

VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryType-02242
queryType must be VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV
VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryPool-02493
queryPool must have been created with a queryType matching queryType
VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryPool-02494
The queries identified by queryPool and firstQuery must be unavailable
VUID-vkCmdWriteAccelerationStructuresPropertiesNV-accelerationStructures-02495
All acceleration structures in accelerationStructures must have been built with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV if queryType is VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV

Valid Usage (Implicit)

VUID-vkCmdWriteAccelerationStructuresPropertiesNV-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdWriteAccelerationStructuresPropertiesNV-pAccelerationStructures-parameter
pAccelerationStructures must be a valid pointer to an array of accelerationStructureCount valid VkAccelerationStructureNV handles
VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryType-parameter
queryType must be a valid VkQueryType value
VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryPool-parameter
queryPool must be a valid VkQueryPool handle
VUID-vkCmdWriteAccelerationStructuresPropertiesNV-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdWriteAccelerationStructuresPropertiesNV-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support compute operations
VUID-vkCmdWriteAccelerationStructuresPropertiesNV-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdWriteAccelerationStructuresPropertiesNV-accelerationStructureCount-arraylength
accelerationStructureCount must be greater than 0
VUID-vkCmdWriteAccelerationStructuresPropertiesNV-commonparent
Each of commandBuffer, queryPool, and the elements of pAccelerationStructures must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Compute

To copy an acceleration structure call:

void vkCmdCopyAccelerationStructureNV(
    VkCommandBuffer                             commandBuffer,
    VkAccelerationStructureNV                   dst,
    VkAccelerationStructureNV                   src,
    VkCopyAccelerationStructureModeNV           mode);

commandBuffer is the command buffer into which the command will be recorded.
dst is a pointer to the target acceleration structure for the copy.
src is a pointer to the source acceleration structure for the copy.
mode is a VkCopyAccelerationStructureModeNV value specifying additional operations to perform during the copy.

Valid Usage

VUID-vkCmdCopyAccelerationStructureNV-mode-02496
mode must be VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV or VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV
VUID-vkCmdCopyAccelerationStructureNV-src-02497
src must have been built with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV if mode is VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV

Valid Usage (Implicit)

VUID-vkCmdCopyAccelerationStructureNV-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdCopyAccelerationStructureNV-dst-parameter
dst must be a valid VkAccelerationStructureNV handle
VUID-vkCmdCopyAccelerationStructureNV-src-parameter
src must be a valid VkAccelerationStructureNV handle
VUID-vkCmdCopyAccelerationStructureNV-mode-parameter
mode must be a valid VkCopyAccelerationStructureModeNV value
VUID-vkCmdCopyAccelerationStructureNV-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdCopyAccelerationStructureNV-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support compute operations
VUID-vkCmdCopyAccelerationStructureNV-renderpass
This command must only be called outside of a render pass instance
VUID-vkCmdCopyAccelerationStructureNV-commonparent
Each of commandBuffer, dst, and src must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Outside

Compute

Possible values of vkCmdCopyAccelerationStructureNV::mode, specifying additional operations to perform during the copy, are:

typedef enum VkCopyAccelerationStructureModeNV {
    VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = 0,
    VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = 1,
    VK_COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_NV = 0x7FFFFFFF
} VkCopyAccelerationStructureModeNV;

VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV creates a direct copy of the acceleration structure specified in src into the one specified by dst. The dst acceleration structure must have been created with the same parameters as src.
VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV creates a more compact version of an acceleration structure src into dst. The acceleration structure dst must have been created with a compactedSize corresponding to the one returned by vkCmdWriteAccelerationStructuresPropertiesNV after the build of the acceleration structure specified by src.

34. Extending Vulkan

New functionality may be added to Vulkan via either new extensions or new versions of the core, or new versions of an extension in some cases.

This chapter describes how Vulkan is versioned, how compatibility is affected between different versions, and compatibility rules that are followed by the Vulkan Working Group.

34.1. Instance and Device Functionality

Commands that enumerate instance properties, or that accept a VkInstance object as a parameter, are considered instance-level functionality. Commands that enumerate physical device properties, or that accept a VkDevice object or any of a device’s child objects as a parameter, are considered device-level functionality.

Note

Applications usually interface to Vulkan using a loader that implements only instance-level functionality, passing device-level functionality to implementations of the full Vulkan API on the system. In some circumstances, as these may be implemented independently, it is possible that the loader and device implementations on a given installation will support different versions. To allow for this and call out when it happens, the Vulkan specification enumerates device and instance level functionality separately - they have independent version queries.

Note

Vulkan 1.0 initially specified new physical device enumeration functionality as instance-level, requiring it to be included in an instance extension. As the capabilities of device-level functionality require discovery via physical device enumeration, this led to the situation where many device extensions required an instance extension as well. To alleviate this extra work, VK_KHR_get_physical_device_properties2 (and subsequently Vulkan 1.1) redefined device-level functionality to include physical device enumeration.

34.2. Core Versions

The Vulkan Specification is regularly updated with bug fixes and clarifications. Occasionally new functionality is added to the core and at some point it is expected that there will be a desire to perform a large, breaking change to the API. In order to indicate to developers how and when these changes are made to the specification, and to provide a way to identify each set of changes, the Vulkan API maintains a version number.

34.2.1. Version Numbers

The Vulkan version number comprises three parts indicating the major, minor and patch version of the Vulkan API Specification.

The major version indicates a significant change in the API, which will encompass a wholly new version of the specification.

The minor version indicates the incorporation of new functionality into the core specification.

The patch version indicates bug fixes, clarifications, and language improvements have been incorporated into the specification.

Compatibility guarantees made about versions of the API sharing any of the same version numbers are documented in Core Versions

The version number is used in several places in the API. In each such use, the version numbers are packed into a 32-bit integer as follows:

The major version 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.

VK_VERSION_MAJOR extracts the API major version number from a packed version number:

#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)

VK_VERSION_MINOR extracts the API minor version number from a packed version number:

#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)

VK_VERSION_PATCH extracts the API patch version number from a packed version number:

#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)

VK_MAKE_VERSION constructs an API version number.

#define VK_MAKE_VERSION(major, minor, patch) \
    (((major) << 22) | ((minor) << 12) | (patch))

major is the major version number.
minor is the minor version number.
patch is the patch version number.

VK_API_VERSION_1_0 returns the API version number for Vulkan 1.0.0.

// Vulkan 1.0 version number
#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0

VK_API_VERSION_1_1 returns the API version number for Vulkan 1.1.0.

// Vulkan 1.1 version number
#define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0

VK_API_VERSION_1_2 returns the API version number for Vulkan 1.2.0.

// Vulkan 1.2 version number
#define VK_API_VERSION_1_2 VK_MAKE_VERSION(1, 2, 0)// Patch version should always be set to 0

34.2.2. Querying Version Support

The version of instance-level functionality can be queried by calling vkEnumerateInstanceVersion.

The version of device-level functionality can be queried by calling vkGetPhysicalDeviceProperties or vkGetPhysicalDeviceProperties2, and is returned in VkPhysicalDeviceProperties::apiVersion, encoded as described in Version Numbers.

34.3. Layers

When a layer is enabled, it inserts itself into the call chain for Vulkan commands the layer is interested in. Layers can be used for a variety of tasks that extend the base behavior of Vulkan beyond what is required by the specification - such as call logging, tracing, validation, or providing additional extensions.

Note

For example, an implementation is not expected to check that the value of 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.

Note

Vulkan layers may wrap object handles (i.e. return a different handle value to the application than that generated by the implementation). This is generally discouraged, as it increases the probability of incompatibilities with new extensions. The validation layers wrap handles in order to track the proper use and destruction of each object. See the “Vulkan Loader Specification and Architecture Overview” document for additional information.

To query the available layers, call:

VkResult vkEnumerateInstanceLayerProperties(
    uint32_t*                                   pPropertyCount,
    VkLayerProperties*                          pProperties);

pPropertyCount is a pointer to an integer related to the number of layer properties available or queried, as described below.
pProperties is either NULL or a pointer to an array of VkLayerProperties structures.

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, VK_INCOMPLETE will be returned instead of VK_SUCCESS, to indicate that not all the available layer properties were returned.

The list of available layers may change at any time due to actions outside of the Vulkan implementation, so two calls to vkEnumerateInstanceLayerProperties with the same parameters may return different results, or retrieve different pPropertyCount values or pProperties contents. Once an instance has been created, the layers enabled for that instance will continue to be enabled and valid for the lifetime of that instance, even if some of them become unavailable for future instances.

Valid Usage (Implicit)

VUID-vkEnumerateInstanceLayerProperties-pPropertyCount-parameter
pPropertyCount must be a valid pointer to a uint32_t value
VUID-vkEnumerateInstanceLayerProperties-pProperties-parameter
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkLayerProperties structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkLayerProperties structure is defined as:

typedef struct VkLayerProperties {
    char        layerName[VK_MAX_EXTENSION_NAME_SIZE];
    uint32_t    specVersion;
    uint32_t    implementationVersion;
    char        description[VK_MAX_DESCRIPTION_SIZE];
} VkLayerProperties;

layerName is an array of VK_MAX_EXTENSION_NAME_SIZE char containing a null-terminated UTF-8 string which is the name of the layer. Use this name in the ppEnabledLayerNames array passed in the VkInstanceCreateInfo structure to enable this layer for an instance.
specVersion is the Vulkan version the layer was written to, encoded as described in Version Numbers.
implementationVersion is the version of this layer. It is an integer, increasing with backward compatible changes.
description is an array of VK_MAX_DESCRIPTION_SIZE char containing a null-terminated UTF-8 string which provides additional details that can be used by the application to identify the layer.

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

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 VkInstanceCreateInfo 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.

34.3.1. Device Layer Deprecation

Previous versions of this specification distinguished between instance and device layers. Instance layers were only able to intercept commands that operate on VkInstance and VkPhysicalDevice, except they were not able to intercept vkCreateDevice. Device layers were enabled for individual devices when they were created, and could only intercept commands operating on that device or its child objects.

Device-only layers are now deprecated, and this specification no longer distinguishes between instance and device layers. Layers are enabled during instance creation, and are able to intercept all commands operating on that instance or any of its child objects. At the time of deprecation there were no known device-only layers and no compelling reason to create one.

In order to maintain compatibility with implementations released prior to device-layer deprecation, applications should still enumerate and enable device layers. The behavior of vkEnumerateDeviceLayerProperties and valid usage of the ppEnabledLayerNames member of VkDeviceCreateInfo maximizes compatibility with applications written to work with the previous requirements.

To enumerate device layers, call:

VkResult vkEnumerateDeviceLayerProperties(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pPropertyCount,
    VkLayerProperties*                          pProperties);

pPropertyCount is a pointer to an integer related to the number of layer properties available or queried.
pProperties is either NULL or a pointer to an array of VkLayerProperties structures.

The list of layers enumerated by vkEnumerateDeviceLayerProperties must be exactly the sequence of layers enabled for the instance. The members of VkLayerProperties for each enumerated layer must be the same as the properties when the layer was enumerated by vkEnumerateInstanceLayerProperties.

Valid Usage (Implicit)

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

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The ppEnabledLayerNames and enabledLayerCount members of VkDeviceCreateInfo are deprecated and their values must be ignored by implementations. However, for compatibility, only an empty list of layers or a list that exactly matches the sequence enabled at instance creation time are valid, and validation layers should issue diagnostics for other cases.

Regardless of the enabled layer list provided in VkDeviceCreateInfo, the sequence of layers active for a device will be exactly the sequence of layers enabled when the parent instance was created.

34.4. 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_core.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 as described in Command Function Pointers. Extensions may be provided by layers as well as by a Vulkan implementation.

Because extensions may extend or change the behavior of the Vulkan API, extension authors should add support for their extensions to the Khronos validation layers. This is especially important for new commands whose parameters have been wrapped by the validation layers. See the “Vulkan Loader Specification and Architecture Overview” document for additional information.

Note

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

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

Physical-Device-Level functionality does not have any enabling mechanism and can be used as long as the VkPhysicalDevice supports the device extension as determined by vkEnumerateDeviceExtensionProperties.

Enabling an extension does not change the behavior of functionality exposed by the core Vulkan API or any other extension, other than making valid the use of the commands, enums and structures defined by that extension.

Valid Usage sections for individual commands and structures do not currently contain which extensions have to be enabled in order to make their use valid, although they might do so in the future. It is defined only in the Valid Usage for Extensions section.

34.4.1. Instance Extensions

Instance extensions add new instance-level functionality to the API, outside of the core specification.

To query the available instance extensions, call:

VkResult vkEnumerateInstanceExtensionProperties(
    const char*                                 pLayerName,
    uint32_t*                                   pPropertyCount,
    VkExtensionProperties*                      pProperties);

pLayerName is either NULL or a pointer to a null-terminated UTF-8 string naming the layer to retrieve extensions from.
pPropertyCount is a pointer to an integer related to the number of extension properties available or queried, as described below.
pProperties is either NULL or a pointer to an array of VkExtensionProperties structures.

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.

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, VK_INCOMPLETE will be returned instead of VK_SUCCESS, to indicate that not all the available properties were returned.

Because the list of available layers may change externally between calls to vkEnumerateInstanceExtensionProperties, two calls may retrieve different results if a pLayerName is available in one call but not in another. The extensions supported by a layer may also change between two calls, e.g. if the layer implementation is replaced by a different version between those calls.

Implementations must not advertise any pair of extensions that cannot be enabled together due to behavioral differences, or any extension that cannot be enabled against the advertised version.

Valid Usage (Implicit)

VUID-vkEnumerateInstanceExtensionProperties-pLayerName-parameter
If pLayerName is not NULL, pLayerName must be a null-terminated UTF-8 string
VUID-vkEnumerateInstanceExtensionProperties-pPropertyCount-parameter
pPropertyCount must be a valid pointer to a uint32_t value
VUID-vkEnumerateInstanceExtensionProperties-pProperties-parameter
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkExtensionProperties structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_LAYER_NOT_PRESENT

34.4.2. Device Extensions

Device extensions add new device-level functionality to the API, outside of the core specification.

To query the extensions available to a given physical device, call:

VkResult vkEnumerateDeviceExtensionProperties(
    VkPhysicalDevice                            physicalDevice,
    const char*                                 pLayerName,
    uint32_t*                                   pPropertyCount,
    VkExtensionProperties*                      pProperties);

physicalDevice is the physical device that will be queried.
pLayerName is either NULL or a pointer to a null-terminated UTF-8 string naming the layer to retrieve extensions from.
pPropertyCount is a pointer to an integer related to the number of extension properties available or queried, and is treated in the same fashion as the vkEnumerateInstanceExtensionProperties::pPropertyCount parameter.
pProperties is either NULL or a pointer to an array of VkExtensionProperties structures.

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.

Implementations must not advertise any pair of extensions that cannot be enabled together due to behavioral differences, or any extension that cannot be enabled against the advertised version.

Valid Usage (Implicit)

VUID-vkEnumerateDeviceExtensionProperties-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkEnumerateDeviceExtensionProperties-pLayerName-parameter
If pLayerName is not NULL, pLayerName must be a null-terminated UTF-8 string
VUID-vkEnumerateDeviceExtensionProperties-pPropertyCount-parameter
pPropertyCount must be a valid pointer to a uint32_t value
VUID-vkEnumerateDeviceExtensionProperties-pProperties-parameter
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkExtensionProperties structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_LAYER_NOT_PRESENT

The VkExtensionProperties structure is defined as:

typedef struct VkExtensionProperties {
    char        extensionName[VK_MAX_EXTENSION_NAME_SIZE];
    uint32_t    specVersion;
} VkExtensionProperties;

extensionName is an array of VK_MAX_EXTENSION_NAME_SIZE char containing a null-terminated UTF-8 string which is the name of the extension.
specVersion is the version of this extension. It is an integer, incremented with backward compatible changes.

34.5. Extension Dependencies

Some extensions are dependent on other extensions to function. To enable extensions with dependencies, such required extensions must also be enabled through the same API mechanisms when creating an instance with vkCreateInstance or a device with vkCreateDevice. Each extension which has such dependencies documents them in the appendix summarizing that extension.

If an extension is supported (as queried by vkEnumerateInstanceExtensionProperties or vkEnumerateDeviceExtensionProperties), then required extensions of that extension must also be supported for the same instance or physical device.

Any device extension that has an instance extension dependency that is not enabled by vkCreateInstance is considered to be unsupported, hence it must not be returned by vkEnumerateDeviceExtensionProperties for any VkPhysicalDevice child of the instance.

If a required extension has been promoted to another extension or to a core API version, then as a general rule, the dependency is also satisfied by the promoted extension or core version. This will be true so long as any features required by the original extension are also required or enabled by the promoted extension or core version. However, in some cases an extension is promoted while making some of its features optional in the promoted extension or core version. In this case, the dependency may not be satisfied. The only way to be certain is to look at the descriptions of the original dependency and the promoted version in the Layers & Extensions and Core Revisions appendices.

Note

There is metadata in vk.xml describing some aspects of promotion, especially requires, promotedto and deprecatedby attributes of <extension> tags. However, the metadata does not yet fully describe this scenario. In the future, we may extend the XML schema to describe the full set of extensions and versions satisfying a dependency.

34.6. Compatibility Guarantees (Informative)

This section is marked as informal as there is no binding responsibility on implementations of the Vulkan API - these guarantees are however a contract between the Vulkan Working Group and developers using this Specification.

34.6.1. Core Versions

Each of the major, minor, and patch versions of the Vulkan specification provide different compatibility guarantees.

Patch Versions

A difference in the patch version indicates that a set of bug fixes or clarifications have been made to the Specification. Informative enums returned by Vulkan commands that will not affect the runtime behavior of a valid application may be added in a patch version (e.g. VkVendorId).

The specification’s patch version is strictly increasing for a given major version of the specification; any change to a specification as described above will result in the patch version being increased by 1. Patch versions are applied to all minor versions, even if a given minor version is not affected by the provoking change.

Specifications with different patch versions but the same major and minor version are fully compatible with each other - such that a valid application written against one will work with an implementation of another.

Note

If a patch version includes a bug fix or clarification that could have a significant impact on developer expectations, these will be highlighted in the change log. Generally the Vulkan Working Group tries to avoid these kinds of changes, instead fixing them in either an extension or core version.

Minor Versions

Changes in the minor version of the specification indicate that new functionality has been added to the core specification. This will usually include new interfaces in the header, and may also include behavior changes and bug fixes. Core functionality may be deprecated in a minor version, but will not be obsoleted or removed.

The specification’s minor version is strictly increasing for a given major version of the specification; any change to a specification as described above will result in the minor version being increased by 1. Changes that can be accomodated in a patch version will not increase the minor version.

Specifications with a lower minor version are backwards compatible with an implementation of a specification with a higher minor version for core functionality and extensions issued with the KHR vendor tag. Vendor and multi-vendor extensions are not guaranteed to remain functional across minor versions, though in general they are with few exceptions - see Obsoletion for more information.

Major Versions

A difference in the major version of specifications indicates a large set of changes which will likely include interface changes, behavioral changes, removal of deprecated functionality, and the modification, addition, or replacement of other functionality.

The specification’s major version is monotonically increasing; any change to the specification as described above will result in the major version being increased. Changes that can be accomodated in a patch or minor version will not increase the major version.

The Vulkan Working Group intends to only issue a new major version of the Specification in order to realise significant improvements to the Vulkan API that will necessarily require breaking compatibility.

A new major version will likely include a wholly new version of the specification to be issued - which could include an overhaul of the versioning semantics for the minor and patch versions. The patch and minor versions of a specification are therefore not meaningful across major versions. If a major version of the specification includes similar versioning semantics, it is expected that the the patch and minor version will be reset to 0 for that major version.

34.6.2. Extensions

A KHR extension must be able to be enabled alongside any other KHR extension, and for any minor or patch version of the core Specification beyond the minimum version it requires. A multi-vendor extension should be able to be enabled alongside any KHR extension or other multi-vendor extension, and for any minor or patch version of the core Specification beyond the minimum version it requires. A vendor extension should be able to be enabled alongside any KHR extension, multi-vendor extension, or other vendor extension from the same vendor, and for any minor or patch version of the core Specification beyond the minimum version it requires. A vendor extension may be able to be enabled alongside vendor extensions from another vendor.

The one other exception to this is if a vendor or multi-vendor extension is made obsolete by either a core version or another extension, which will be highlighted in the extension appendix.

Promotion

Extensions, or features of an extension, may be promoted to a new core version of the API, or a newer extension which an equal or greater number of implementors are in favour of.

When extension functionality is promoted, minor changes may be introduced, limited to the following:

Naming
Non-intrusive parameters changes
Feature advertisement/enablement
Combining structure parameters into larger structures
Author ID suffixes changed or removed

Note

If extension functionality is promoted, there is no guarantee of direct compatibility, however it should require little effort to port code from the original feature to the promoted one.

The Vulkan Working Group endeavours to ensure that larger changes are marked as either deprecated or obsoleted as appropriate, and can do so retroactively if necessary.

Extensions that are promoted are listed as being promoted in their extension appendices, with reference to where they were promoted to.

When an extension is promoted, any backwards compatibility aliases which exist in the extension will not be promoted.

Note

As a hypothetical example, if the VK_KHR_surface extension were promoted to part of a future core version, the VK_COLOR_SPACE_SRGB_NONLINEAR_KHR token defined by that extension would be promoted to VK_COLOR_SPACE_SRGB_NONLINEAR. However, the VK_COLORSPACE_SRGB_NONLINEAR_KHR token aliases VK_COLOR_SPACE_SRGB_NONLINEAR_KHR. The VK_COLORSPACE_SRGB_NONLINEAR_KHR would not be promoted, because it is a backwards compatibility alias that exists only due to a naming mistake when the extension was initially published.

Deprecation

Extensions may be marked as deprecated when the intended use cases either become irrelevant or can be solved in other ways. Generally, a new feature will become available to solve the use case in another extension or core version of the API, but it is not guaranteed.

Note

Features that are intended to replace deprecated functionality have no guarantees of compatibility, and applications may require drastic modification in order to make use of the new features.

Extensions that are deprecated are listed as being deprecated in their extension appendices, with an explanation of the deprecation and any features that are relevant.

Obsoletion

Occasionally, an extension will be marked as obsolete if a new version of the core API or a new extension is fundamentally incompatible with it. An obsoleted extension must not be used with the extension or core version that obsoleted it.

Extensions that are obsoleted are listed as being obsoleted in their extension appendices, with reference to what they were obsoleted by.

Aliases

When an extension is promoted or deprecated by a newer feature, some or all of its functionality may be replicated into the newer feature. Rather than duplication of all the documentation and definitions, the specification instead identifies the identical commands and types as aliases of one another. Each alias is mentioned together with the definition it aliases, with the older aliases marked as “equivalents”. Each alias of the same command has identical behavior, and each alias of the same type has identical meaning - they can be used interchangably in an application with no compatibility issues.

Note

For promoted types, the aliased extension type is semantically identical to the new core type. The C99 headers simply typedef the older aliases to the promoted types.

For promoted command aliases, however, there are two separate entry point definitions, due to the fact that the C99 ABI has no way to alias command definitions without resorting to macros. Calling via either entry point definition will produce identical behavior within the bounds of the specification, and should still invoke the same entry point in the implementation. Debug tools may use separate entry points with different debug behavior; to write the appropriate command name to an output log, for instance.

35. Features

Features describe functionality which is not supported on all implementations. Features are properties of the physical device. Features are optional, and must be explicitly enabled before use. Support for features is reported and enabled on a per-feature basis.

Note

Features are reported via the basic VkPhysicalDeviceFeatures structure, as well as the extensible structure VkPhysicalDeviceFeatures2, which was added in the [VK_KHR_get_physical_device_properties2] extension and included in Vulkan 1.1. When new features are added in future Vulkan versions or extensions, each extension should introduce one new feature structure, if needed. This structure can be added to the pNext chain of the VkPhysicalDeviceFeatures2 structure.

For convenience, new core versions of Vulkan may introduce new unified features structures for features promoted from extensions. At the same time, the extension’s original features structure (if any) is also promoted to the core API, and is an alias of the extension’s structure. This results in multiple names for the same feature: in the original extension’s feature structure and the promoted structure alias, in the unified feature structure. When a feature was implicitly supported and enabled in the extension, but an explicit name was added during promotion, then the extension itself acts as an alias for the feature as listed in the table below.

All aliases of the same feature in the core API must be reported consistently: either all must be reported as supported, or none of them. When a promoted extension is available, any corresponding feature aliases must be supported.

Table 44. Extension Feature Aliases
Extension	Feature(s)
`[VK_KHR_draw_indirect_count]`	drawIndirectCount
`[VK_KHR_sampler_mirror_clamp_to_edge]`	samplerMirrorClampToEdge
`[VK_EXT_descriptor_indexing]`	descriptorIndexing
`[VK_EXT_sampler_filter_minmax]`	samplerFilterMinmax
`[VK_EXT_shader_viewport_index_layer]`	shaderOutputViewportIndex, shaderOutputLayer

To query supported features, call:

void vkGetPhysicalDeviceFeatures(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceFeatures*                   pFeatures);

physicalDevice is the physical device from which to query the supported features.
pFeatures is a pointer to a VkPhysicalDeviceFeatures structure in which the physical device features are returned. For each feature, a value of VK_TRUE specifies that the feature is supported on this physical device, and VK_FALSE specifies that the feature is not supported.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceFeatures-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceFeatures-pFeatures-parameter
pFeatures must be a valid pointer to a VkPhysicalDeviceFeatures structure

Fine-grained features used by a logical device must be enabled at VkDevice creation time. If a feature is enabled that the physical device does not support, VkDevice creation will fail and return VK_ERROR_FEATURE_NOT_PRESENT.

The fine-grained features are enabled by passing a pointer to the VkPhysicalDeviceFeatures structure via the pEnabledFeatures member of the VkDeviceCreateInfo structure that is passed into the vkCreateDevice call. If a member of pEnabledFeatures is set to VK_TRUE or VK_FALSE, then the device will be created with the indicated feature enabled or disabled, respectively. Features can also be enabled by using the VkPhysicalDeviceFeatures2 structure.

If an application wishes to enable all features supported by a device, it can simply pass in the VkPhysicalDeviceFeatures structure that was previously returned by vkGetPhysicalDeviceFeatures. To disable an individual feature, the application can set the desired member to VK_FALSE in the same structure. Setting pEnabledFeatures to NULL and not including a VkPhysicalDeviceFeatures2 in the pNext chain of VkDeviceCreateInfo is equivalent to setting all members of the structure to VK_FALSE.

Note

Some features, such as robustBufferAccess, may incur a run-time performance cost. Application writers should carefully consider the implications of enabling all supported features.

To query supported features defined by the core or extensions, call:

void vkGetPhysicalDeviceFeatures2(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceFeatures2*                  pFeatures);

or the equivalent command

void vkGetPhysicalDeviceFeatures2KHR(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceFeatures2*                  pFeatures);

physicalDevice is the physical device from which to query the supported features.
pFeatures is a pointer to a VkPhysicalDeviceFeatures2 structure in which the physical device features are returned.

Each structure in pFeatures and its pNext chain contains members corresponding to fine-grained features. vkGetPhysicalDeviceFeatures2 writes each member to a boolean value indicating whether that feature is supported.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceFeatures2-pFeatures-parameter
pFeatures must be a valid pointer to a VkPhysicalDeviceFeatures2 structure

The VkPhysicalDeviceFeatures2 structure is defined as:

typedef struct VkPhysicalDeviceFeatures2 {
    VkStructureType             sType;
    void*                       pNext;
    VkPhysicalDeviceFeatures    features;
} VkPhysicalDeviceFeatures2;

or the equivalent

typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR;

The VkPhysicalDeviceFeatures2 structure is defined as:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
features is a VkPhysicalDeviceFeatures structure describing the fine-grained features of the Vulkan 1.0 API.

The pNext chain of this structure is used to extend the structure with features defined by extensions. This structure can be used in vkGetPhysicalDeviceFeatures2 or can be included in the pNext chain of a VkDeviceCreateInfo structure, in which case it controls which features are enabled in the device in lieu of pEnabledFeatures.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceFeatures2-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2

The VkPhysicalDeviceFeatures structure is defined as:

typedef struct VkPhysicalDeviceFeatures {
    VkBool32    robustBufferAccess;
    VkBool32    fullDrawIndexUint32;
    VkBool32    imageCubeArray;
    VkBool32    independentBlend;
    VkBool32    geometryShader;
    VkBool32    tessellationShader;
    VkBool32    sampleRateShading;
    VkBool32    dualSrcBlend;
    VkBool32    logicOp;
    VkBool32    multiDrawIndirect;
    VkBool32    drawIndirectFirstInstance;
    VkBool32    depthClamp;
    VkBool32    depthBiasClamp;
    VkBool32    fillModeNonSolid;
    VkBool32    depthBounds;
    VkBool32    wideLines;
    VkBool32    largePoints;
    VkBool32    alphaToOne;
    VkBool32    multiViewport;
    VkBool32    samplerAnisotropy;
    VkBool32    textureCompressionETC2;
    VkBool32    textureCompressionASTC_LDR;
    VkBool32    textureCompressionBC;
    VkBool32    occlusionQueryPrecise;
    VkBool32    pipelineStatisticsQuery;
    VkBool32    vertexPipelineStoresAndAtomics;
    VkBool32    fragmentStoresAndAtomics;
    VkBool32    shaderTessellationAndGeometryPointSize;
    VkBool32    shaderImageGatherExtended;
    VkBool32    shaderStorageImageExtendedFormats;
    VkBool32    shaderStorageImageMultisample;
    VkBool32    shaderStorageImageReadWithoutFormat;
    VkBool32    shaderStorageImageWriteWithoutFormat;
    VkBool32    shaderUniformBufferArrayDynamicIndexing;
    VkBool32    shaderSampledImageArrayDynamicIndexing;
    VkBool32    shaderStorageBufferArrayDynamicIndexing;
    VkBool32    shaderStorageImageArrayDynamicIndexing;
    VkBool32    shaderClipDistance;
    VkBool32    shaderCullDistance;
    VkBool32    shaderFloat64;
    VkBool32    shaderInt64;
    VkBool32    shaderInt16;
    VkBool32    shaderResourceResidency;
    VkBool32    shaderResourceMinLod;
    VkBool32    sparseBinding;
    VkBool32    sparseResidencyBuffer;
    VkBool32    sparseResidencyImage2D;
    VkBool32    sparseResidencyImage3D;
    VkBool32    sparseResidency2Samples;
    VkBool32    sparseResidency4Samples;
    VkBool32    sparseResidency8Samples;
    VkBool32    sparseResidency16Samples;
    VkBool32    sparseResidencyAliased;
    VkBool32    variableMultisampleRate;
    VkBool32    inheritedQueries;
} VkPhysicalDeviceFeatures;

The members of the VkPhysicalDeviceFeatures structure describe the following features:

robustBufferAccess specifies that accesses to buffers are bounds-checked against the range of the buffer descriptor (as determined by VkDescriptorBufferInfo::range, VkBufferViewCreateInfo::range, or the size of the buffer). Out of bounds accesses must not cause application termination, and the effects of shader loads, stores, and atomics must conform to an implementation-dependent behavior as described below.

A buffer access is considered to be out of bounds if any of the following are true:

The pointer was formed by OpImageTexelPointer and the coordinate is less than zero or greater than or equal to the number of whole elements in the bound range.

The pointer was not formed by OpImageTexelPointer and the object pointed to is not wholly contained within the bound range. This includes accesses performed via variable pointers where the buffer descriptor being accessed cannot be statically determined. Uninitialized pointers and pointers equal to OpConstantNull are treated as pointing to a zero-sized object, so all accesses through such pointers are considered to be out of bounds. Buffer accesses through buffer device addresses are not bounds-checked. If the cooperativeMatrixRobustBufferAccess feature is not enabled, then accesses using OpCooperativeMatrixLoadNV and OpCooperativeMatrixStoreNV may not be bounds-checked.

Note

If a SPIR-V OpLoad instruction loads a structure and the tail end of the structure is out of bounds, then all members of the structure are considered out of bounds even if the members at the end are not statically used.

If any buffer access is determined to be out of bounds, then any other access of the same type (load, store, or atomic) to the same buffer that accesses an address less than 16 bytes away from the out of bounds address may also be considered out of bounds.

Out-of-bounds buffer loads will return any of the following values:
- Values from anywhere within the memory range(s) bound to the buffer (possibly including bytes of memory past the end of the buffer, up to the end of the bound range).
- Zero values, or (0,0,0,x) vectors for vector reads where x is a valid value represented in the type of the vector components and may be any of:
  - 0, 1, or the maximum representable positive integer value, for signed or unsigned integer components
  - 0.0 or 1.0, for floating-point components
Out-of-bounds writes may modify values within the memory range(s) bound to the buffer, but must not modify any other memory.
Out-of-bounds atomics may modify values within the memory range(s) bound to the buffer, but must not modify any other memory, and return an undefined value.
Vertex input attributes are considered out of bounds if the offset of the attribute in the bound vertex buffer range plus the size of the attribute is greater than either:
- vertexBufferRangeSize, if bindingStride == 0; or
- (vertexBufferRangeSize - (vertexBufferRangeSize % bindingStride))
where vertexBufferRangeSize is the byte size of the memory range bound to the vertex buffer binding and bindingStride is the byte stride of the corresponding vertex input binding. Further, if any vertex input attribute using a specific vertex input binding is out of bounds, then all vertex input attributes using that vertex input binding for that vertex shader invocation are considered out of bounds.
- If a vertex input attribute is out of bounds, it will be assigned one of the following values:
  - Values from anywhere within the memory range(s) bound to the buffer, converted according to the format of the attribute.
  - Zero values, format converted according to the format of the attribute.
  - Zero values, or (0,0,0,x) vectors, as described above.
If robustBufferAccess is not enabled, applications must not perform out of bounds accesses.

fullDrawIndexUint32 specifies the full 32-bit range of indices is supported for indexed draw calls when using a VkIndexType of VK_INDEX_TYPE_UINT32. maxDrawIndexedIndexValue is the maximum index value that may be used (aside from the primitive restart index, which is always 2³²-1 when the VkIndexType is VK_INDEX_TYPE_UINT32). If this feature is supported, maxDrawIndexedIndexValue must be 2³²-1; otherwise it must be no smaller than 2²⁴-1. See maxDrawIndexedIndexValue.
imageCubeArray specifies whether image views with a VkImageViewType of VK_IMAGE_VIEW_TYPE_CUBE_ARRAY can be created, and that the corresponding SampledCubeArray and ImageCubeArray SPIR-V capabilities can be used in shader code.
independentBlend specifies whether the VkPipelineColorBlendAttachmentState settings are controlled independently per-attachment. If this feature is not enabled, the VkPipelineColorBlendAttachmentState settings for all color attachments must be identical. Otherwise, a different VkPipelineColorBlendAttachmentState can be provided for each bound color attachment.
geometryShader specifies whether geometry shaders are supported. If this feature is not enabled, the VK_SHADER_STAGE_GEOMETRY_BIT and VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT enum values must not be used. This also specifies whether shader modules can declare the Geometry capability.
tessellationShader specifies whether tessellation control and evaluation shaders are supported. If this feature is not enabled, the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, and VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO enum values must not be used. This also specifies whether shader modules can declare the Tessellation capability.
sampleRateShading specifies whether Sample Shading and multisample interpolation are supported. If this feature is not enabled, the sampleShadingEnable member of the VkPipelineMultisampleStateCreateInfo structure must be set to VK_FALSE and the minSampleShading member is ignored. This also specifies whether shader modules can declare the SampleRateShading capability.
dualSrcBlend specifies whether blend operations which take two sources are supported. If this feature is not enabled, the VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, and VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA enum values must not be used as source or destination blending factors. See Dual-Source Blending.
logicOp specifies whether logic operations are supported. If this feature is not enabled, the logicOpEnable member of the VkPipelineColorBlendStateCreateInfo structure must be set to VK_FALSE, and the logicOp member is ignored.
multiDrawIndirect specifies whether multiple draw indirect is supported. If this feature is not enabled, the drawCount parameter to the vkCmdDrawIndirect and vkCmdDrawIndexedIndirect commands must be 0 or 1. The maxDrawIndirectCount member of the VkPhysicalDeviceLimits structure must also be 1 if this feature is not supported. See maxDrawIndirectCount.
drawIndirectFirstInstance specifies whether indirect draw calls support the firstInstance parameter. If this feature is not enabled, the firstInstance member of all VkDrawIndirectCommand and VkDrawIndexedIndirectCommand structures that are provided to the vkCmdDrawIndirect and vkCmdDrawIndexedIndirect commands must be 0.
depthClamp specifies whether depth clamping is supported. If this feature is not enabled, the depthClampEnable member of the VkPipelineRasterizationStateCreateInfo structure must be set to VK_FALSE. Otherwise, setting depthClampEnable to VK_TRUE will enable depth clamping.
depthBiasClamp specifies whether depth bias clamping is supported. If this feature is not enabled, the depthBiasClamp member of the VkPipelineRasterizationStateCreateInfo structure must be set to 0.0 unless the VK_DYNAMIC_STATE_DEPTH_BIAS dynamic state is enabled, and the depthBiasClamp parameter to vkCmdSetDepthBias must be set to 0.0.
fillModeNonSolid specifies whether point and wireframe fill modes are supported. If this feature is not enabled, the VK_POLYGON_MODE_POINT and VK_POLYGON_MODE_LINE enum values must not be used.
depthBounds specifies whether depth bounds tests are supported. If this feature is not enabled, the depthBoundsTestEnable member of the VkPipelineDepthStencilStateCreateInfo structure must be set to VK_FALSE. When depthBoundsTestEnable is set to VK_FALSE, the minDepthBounds and maxDepthBounds members of the VkPipelineDepthStencilStateCreateInfo structure are ignored.
wideLines specifies whether lines with width other than 1.0 are supported. If this feature is not enabled, the lineWidth member of the VkPipelineRasterizationStateCreateInfo structure must be set to 1.0 unless the VK_DYNAMIC_STATE_LINE_WIDTH dynamic state is enabled, and the lineWidth parameter to vkCmdSetLineWidth must be set to 1.0. When this feature is supported, the range and granularity of supported line widths are indicated by the lineWidthRange and lineWidthGranularity members of the VkPhysicalDeviceLimits structure, respectively.
largePoints specifies whether points with size greater than 1.0 are supported. If this feature is not enabled, only a point size of 1.0 written by a shader is supported. The range and granularity of supported point sizes are indicated by the pointSizeRange and pointSizeGranularity members of the VkPhysicalDeviceLimits structure, respectively.
alphaToOne specifies whether the implementation is able to replace the alpha value of the color fragment output from the fragment shader with the maximum representable alpha value for fixed-point colors or 1.0 for floating-point colors. If this feature is not enabled, then the alphaToOneEnable member of the VkPipelineMultisampleStateCreateInfo structure must be set to VK_FALSE. Otherwise setting alphaToOneEnable to VK_TRUE will enable alpha-to-one behavior.
multiViewport specifies whether more than one viewport is supported. If this feature is not enabled:
- The viewportCount and scissorCount members of the VkPipelineViewportStateCreateInfo structure must be set to 1.
- The firstViewport and viewportCount parameters to the vkCmdSetViewport command must be set to 0 and 1, respectively.
- The firstScissor and scissorCount parameters to the vkCmdSetScissor command must be set to 0 and 1, respectively.
- The exclusiveScissorCount member of the VkPipelineViewportExclusiveScissorStateCreateInfoNV structure must be set to 0 or 1.
- The firstExclusiveScissor and exclusiveScissorCount parameters to the vkCmdSetExclusiveScissorNV command must be set to 0 and 1, respectively.
samplerAnisotropy specifies whether anisotropic filtering is supported. If this feature is not enabled, the anisotropyEnable member of the VkSamplerCreateInfo structure must be VK_FALSE.
textureCompressionETC2 specifies whether all of the ETC2 and EAC compressed texture formats are supported. If this feature is enabled, then the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, VK_FORMAT_FEATURE_BLIT_SRC_BIT and VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT features must be supported in optimalTilingFeatures for the following formats:
- VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK
- VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK
- VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK
- VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK
- VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK
- VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK
- VK_FORMAT_EAC_R11_UNORM_BLOCK
- VK_FORMAT_EAC_R11_SNORM_BLOCK
- VK_FORMAT_EAC_R11G11_UNORM_BLOCK
- VK_FORMAT_EAC_R11G11_SNORM_BLOCK
To query for additional properties, or if the feature is not enabled, vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats as normal.
textureCompressionASTC_LDR specifies whether all of the ASTC LDR compressed texture formats are supported. If this feature is enabled, then the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, VK_FORMAT_FEATURE_BLIT_SRC_BIT and VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT features must be supported in optimalTilingFeatures for the following formats:
- VK_FORMAT_ASTC_4x4_UNORM_BLOCK
- VK_FORMAT_ASTC_4x4_SRGB_BLOCK
- VK_FORMAT_ASTC_5x4_UNORM_BLOCK
- VK_FORMAT_ASTC_5x4_SRGB_BLOCK
- VK_FORMAT_ASTC_5x5_UNORM_BLOCK
- VK_FORMAT_ASTC_5x5_SRGB_BLOCK
- VK_FORMAT_ASTC_6x5_UNORM_BLOCK
- VK_FORMAT_ASTC_6x5_SRGB_BLOCK
- VK_FORMAT_ASTC_6x6_UNORM_BLOCK
- VK_FORMAT_ASTC_6x6_SRGB_BLOCK
- VK_FORMAT_ASTC_8x5_UNORM_BLOCK
- VK_FORMAT_ASTC_8x5_SRGB_BLOCK
- VK_FORMAT_ASTC_8x6_UNORM_BLOCK
- VK_FORMAT_ASTC_8x6_SRGB_BLOCK
- VK_FORMAT_ASTC_8x8_UNORM_BLOCK
- VK_FORMAT_ASTC_8x8_SRGB_BLOCK
- VK_FORMAT_ASTC_10x5_UNORM_BLOCK
- VK_FORMAT_ASTC_10x5_SRGB_BLOCK
- VK_FORMAT_ASTC_10x6_UNORM_BLOCK
- VK_FORMAT_ASTC_10x6_SRGB_BLOCK
- VK_FORMAT_ASTC_10x8_UNORM_BLOCK
- VK_FORMAT_ASTC_10x8_SRGB_BLOCK
- VK_FORMAT_ASTC_10x10_UNORM_BLOCK
- VK_FORMAT_ASTC_10x10_SRGB_BLOCK
- VK_FORMAT_ASTC_12x10_UNORM_BLOCK
- VK_FORMAT_ASTC_12x10_SRGB_BLOCK
- VK_FORMAT_ASTC_12x12_UNORM_BLOCK
- VK_FORMAT_ASTC_12x12_SRGB_BLOCK
To query for additional properties, or if the feature is not enabled, vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats as normal.
textureCompressionBC specifies whether all of the BC compressed texture formats are supported. If this feature is enabled, then the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, VK_FORMAT_FEATURE_BLIT_SRC_BIT and VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT features must be supported in optimalTilingFeatures for the following formats:
- VK_FORMAT_BC1_RGB_UNORM_BLOCK
- VK_FORMAT_BC1_RGB_SRGB_BLOCK
- VK_FORMAT_BC1_RGBA_UNORM_BLOCK
- VK_FORMAT_BC1_RGBA_SRGB_BLOCK
- VK_FORMAT_BC2_UNORM_BLOCK
- VK_FORMAT_BC2_SRGB_BLOCK
- VK_FORMAT_BC3_UNORM_BLOCK
- VK_FORMAT_BC3_SRGB_BLOCK
- VK_FORMAT_BC4_UNORM_BLOCK
- VK_FORMAT_BC4_SNORM_BLOCK
- VK_FORMAT_BC5_UNORM_BLOCK
- VK_FORMAT_BC5_SNORM_BLOCK
- VK_FORMAT_BC6H_UFLOAT_BLOCK
- VK_FORMAT_BC6H_SFLOAT_BLOCK
- VK_FORMAT_BC7_UNORM_BLOCK
- VK_FORMAT_BC7_SRGB_BLOCK
To query for additional properties, or if the feature is not enabled, vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats as normal.
occlusionQueryPrecise specifies whether occlusion queries returning actual sample counts are supported. Occlusion queries are created in a VkQueryPool by specifying the queryType of VK_QUERY_TYPE_OCCLUSION in the VkQueryPoolCreateInfo structure which is passed to vkCreateQueryPool. If this feature is enabled, queries of this type can enable VK_QUERY_CONTROL_PRECISE_BIT in the flags parameter to vkCmdBeginQuery. If this feature is not supported, the implementation supports only boolean occlusion queries. When any samples are passed, boolean queries will return a non-zero result value, otherwise a result value of zero is returned. When this feature is enabled and VK_QUERY_CONTROL_PRECISE_BIT is set, occlusion queries will report the actual number of samples passed.
pipelineStatisticsQuery specifies whether the pipeline statistics queries are supported. If this feature is not enabled, queries of type VK_QUERY_TYPE_PIPELINE_STATISTICS cannot be created, and none of the VkQueryPipelineStatisticFlagBits bits can be set in the pipelineStatistics member of the VkQueryPoolCreateInfo structure.
vertexPipelineStoresAndAtomics specifies whether storage buffers and images support stores and atomic operations in the vertex, tessellation, and geometry shader stages. If this feature is not enabled, all storage image, storage texel buffers, and storage buffer variables used by these stages in shader modules must be decorated with the NonWritable decoration (or the readonly memory qualifier in GLSL).
fragmentStoresAndAtomics specifies whether storage buffers and images support stores and atomic operations in the fragment shader stage. If this feature is not enabled, all storage image, storage texel buffers, and storage buffer variables used by the fragment stage in shader modules must be decorated with the NonWritable decoration (or the readonly memory qualifier in GLSL).
shaderTessellationAndGeometryPointSize specifies whether the PointSize built-in decoration is available in the tessellation control, tessellation evaluation, and geometry shader stages. If this feature is not enabled, members decorated with the PointSize built-in decoration must not be read from or written to and all points written from a tessellation or geometry shader will have a size of 1.0. This also specifies whether shader modules can declare the TessellationPointSize capability for tessellation control and evaluation shaders, or if the shader modules can declare the GeometryPointSize capability for geometry shaders. An implementation supporting this feature must also support one or both of the tessellationShader or geometryShader features.
shaderImageGatherExtended specifies whether the extended set of image gather instructions are available in shader code. If this feature is not enabled, the OpImage*Gather instructions do not support the Offset and ConstOffsets operands. This also specifies whether shader modules can declare the ImageGatherExtended capability.

shaderStorageImageExtendedFormats specifies whether all the “storage image extended formats” below are supported; if this feature is supported, then the VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT must be supported in optimalTilingFeatures for the following formats:

VK_FORMAT_R16G16_SFLOAT
VK_FORMAT_B10G11R11_UFLOAT_PACK32
VK_FORMAT_R16_SFLOAT
VK_FORMAT_R16G16B16A16_UNORM
VK_FORMAT_A2B10G10R10_UNORM_PACK32
VK_FORMAT_R16G16_UNORM
VK_FORMAT_R8G8_UNORM
VK_FORMAT_R16_UNORM
VK_FORMAT_R8_UNORM
VK_FORMAT_R16G16B16A16_SNORM
VK_FORMAT_R16G16_SNORM
VK_FORMAT_R8G8_SNORM
VK_FORMAT_R16_SNORM
VK_FORMAT_R8_SNORM
VK_FORMAT_R16G16_SINT
VK_FORMAT_R8G8_SINT
VK_FORMAT_R16_SINT
VK_FORMAT_R8_SINT
VK_FORMAT_A2B10G10R10_UINT_PACK32
VK_FORMAT_R16G16_UINT
VK_FORMAT_R8G8_UINT
VK_FORMAT_R16_UINT
VK_FORMAT_R8_UINT

Note

shaderStorageImageExtendedFormats feature only adds a guarantee of format support, which is specified for the whole physical device. Therefore enabling or disabling the feature via vkCreateDevice has no practical effect.

To query for additional properties, or if the feature is not supported, vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats, as usual rules allow.

VK_FORMAT_R32G32_UINT, VK_FORMAT_R32G32_SINT, and VK_FORMAT_R32G32_SFLOAT from StorageImageExtendedFormats SPIR-V capability, are already covered by core Vulkan mandatory format support.

shaderStorageImageMultisample specifies whether multisampled storage images are supported. If this feature is not enabled, images that are created with a usage that includes VK_IMAGE_USAGE_STORAGE_BIT must be created with samples equal to VK_SAMPLE_COUNT_1_BIT. This also specifies whether shader modules can declare the StorageImageMultisample capability.
shaderStorageImageReadWithoutFormat specifies whether storage images require a format qualifier to be specified when reading from storage images. If this feature is not enabled, the OpImageRead instruction must not have an OpTypeImage of Unknown. This also specifies whether shader modules can declare the StorageImageReadWithoutFormat capability.
shaderStorageImageWriteWithoutFormat specifies whether storage images require a format qualifier to be specified when writing to storage images. If this feature is not enabled, the OpImageWrite instruction must not have an OpTypeImage of Unknown. This also specifies whether shader modules can declare the StorageImageWriteWithoutFormat capability.
shaderUniformBufferArrayDynamicIndexing specifies whether arrays of uniform buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the UniformBufferArrayDynamicIndexing capability.
shaderSampledImageArrayDynamicIndexing specifies whether arrays of samplers or sampled images can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, or VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the SampledImageArrayDynamicIndexing capability.
shaderStorageBufferArrayDynamicIndexing specifies whether arrays of storage buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the StorageBufferArrayDynamicIndexing capability.
shaderStorageImageArrayDynamicIndexing specifies whether arrays of storage images can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the StorageImageArrayDynamicIndexing capability.
shaderClipDistance specifies whether clip distances are supported in shader code. If this feature is not enabled, any members decorated with the ClipDistance built-in decoration must not be read from or written to in shader modules. This also specifies whether shader modules can declare the ClipDistance capability.
shaderCullDistance specifies whether cull distances are supported in shader code. If this feature is not enabled, any members decorated with the CullDistance built-in decoration must not be read from or written to in shader modules. This also specifies whether shader modules can declare the CullDistance capability.
shaderFloat64 specifies whether 64-bit floats (doubles) are supported in shader code. If this feature is not enabled, 64-bit floating-point types must not be used in shader code. This also specifies whether shader modules can declare the Float64 capability. Declaring and using 64-bit floats is enabled for all storage classes that SPIR-V allows with the Float64 capability.
shaderInt64 specifies whether 64-bit integers (signed and unsigned) are supported in shader code. If this feature is not enabled, 64-bit integer types must not be used in shader code. This also specifies whether shader modules can declare the Int64 capability. Declaring and using 64-bit integers is enabled for all storage classes that SPIR-V allows with the Int64 capability.
shaderInt16 specifies whether 16-bit integers (signed and unsigned) are supported in shader code. If this feature is not enabled, 16-bit integer types must not be used in shader code. This also specifies whether shader modules can declare the Int16 capability. However, this only enables a subset of the storage classes that SPIR-V allows for the Int16 SPIR-V capability: Declaring and using 16-bit integers in the Private, Workgroup, and Function storage classes is enabled, while declaring them in the interface storage classes (e.g., UniformConstant, Uniform, StorageBuffer, Input, Output, and PushConstant) is not enabled.
shaderResourceResidency specifies whether image operations that return resource residency information are supported in shader code. If this feature is not enabled, the OpImageSparse* instructions must not be used in shader code. This also specifies whether shader modules can declare the SparseResidency capability. The feature requires at least one of the sparseResidency* features to be supported.
shaderResourceMinLod specifies whether image operations specifying the minimum resource LOD are supported in shader code. If this feature is not enabled, the MinLod image operand must not be used in shader code. This also specifies whether shader modules can declare the MinLod capability.
sparseBinding specifies whether resource memory can be managed at opaque sparse block level instead of at the object level. If this feature is not enabled, resource memory must be bound only on a per-object basis using the vkBindBufferMemory and vkBindImageMemory commands. In this case, buffers and images must not be created with VK_BUFFER_CREATE_SPARSE_BINDING_BIT and VK_IMAGE_CREATE_SPARSE_BINDING_BIT set in the flags member of the VkBufferCreateInfo and VkImageCreateInfo structures, respectively. Otherwise resource memory can be managed as described in Sparse Resource Features.
sparseResidencyBuffer specifies whether the device can access partially resident buffers. If this feature is not enabled, buffers must not be created with VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the VkBufferCreateInfo structure.
sparseResidencyImage2D specifies whether the device can access partially resident 2D images with 1 sample per pixel. If this feature is not enabled, images with an imageType of VK_IMAGE_TYPE_2D and samples set to VK_SAMPLE_COUNT_1_BIT must not be created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the VkImageCreateInfo structure.
sparseResidencyImage3D specifies whether the device can access partially resident 3D images. If this feature is not enabled, images with an imageType of VK_IMAGE_TYPE_3D must not be created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the VkImageCreateInfo structure.
sparseResidency2Samples specifies whether the physical device can access partially resident 2D images with 2 samples per pixel. If this feature is not enabled, images with an imageType of VK_IMAGE_TYPE_2D and samples set to VK_SAMPLE_COUNT_2_BIT must not be created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the VkImageCreateInfo structure.
sparseResidency4Samples specifies whether the physical device can access partially resident 2D images with 4 samples per pixel. If this feature is not enabled, images with an imageType of VK_IMAGE_TYPE_2D and samples set to VK_SAMPLE_COUNT_4_BIT must not be created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the VkImageCreateInfo structure.
sparseResidency8Samples specifies whether the physical device can access partially resident 2D images with 8 samples per pixel. If this feature is not enabled, images with an imageType of VK_IMAGE_TYPE_2D and samples set to VK_SAMPLE_COUNT_8_BIT must not be created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the VkImageCreateInfo structure.
sparseResidency16Samples specifies whether the physical device can access partially resident 2D images with 16 samples per pixel. If this feature is not enabled, images with an imageType of VK_IMAGE_TYPE_2D and samples set to VK_SAMPLE_COUNT_16_BIT must not be created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the VkImageCreateInfo structure.
sparseResidencyAliased specifies whether the physical device can correctly access data aliased into multiple locations. If this feature is not enabled, the VK_BUFFER_CREATE_SPARSE_ALIASED_BIT and VK_IMAGE_CREATE_SPARSE_ALIASED_BIT enum values must not be used in flags members of the VkBufferCreateInfo and VkImageCreateInfo structures, respectively.
variableMultisampleRate specifies whether all pipelines that will be bound to a command buffer during a subpass with no attachments must have the same value for VkPipelineMultisampleStateCreateInfo::rasterizationSamples. If set to VK_TRUE, the implementation supports variable multisample rates in a subpass with no attachments. If set to VK_FALSE, then all pipelines bound in such a subpass must have the same multisample rate. This has no effect in situations where a subpass uses any attachments.
inheritedQueries specifies whether a secondary command buffer may be executed while a query is active.

The VkPhysicalDeviceVulkan11Features structure is defined as:

typedef struct VkPhysicalDeviceVulkan11Features {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           storageBuffer16BitAccess;
    VkBool32           uniformAndStorageBuffer16BitAccess;
    VkBool32           storagePushConstant16;
    VkBool32           storageInputOutput16;
    VkBool32           multiview;
    VkBool32           multiviewGeometryShader;
    VkBool32           multiviewTessellationShader;
    VkBool32           variablePointersStorageBuffer;
    VkBool32           variablePointers;
    VkBool32           protectedMemory;
    VkBool32           samplerYcbcrConversion;
    VkBool32           shaderDrawParameters;
} VkPhysicalDeviceVulkan11Features;

The members of the VkPhysicalDeviceVulkan11Features structure describe the following features:

storageBuffer16BitAccess specifies whether objects in the StorageBuffer or PhysicalStorageBuffer storage class with the Block decoration can have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or 16-bit floating-point members must not be used in such objects. This also specifies whether shader modules can declare the StorageBuffer16BitAccess capability.
uniformAndStorageBuffer16BitAccess specifies whether objects in the Uniform storage class with the Block decoration and in the StorageBuffer or PhysicalStorageBuffer storage class with the same decoration can have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or 16-bit floating-point members must not be used in such objects. This also specifies whether shader modules can declare the UniformAndStorageBuffer16BitAccess capability.
storagePushConstant16 specifies whether objects in the PushConstant storage class can have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or floating-point members must not be used in such objects. This also specifies whether shader modules can declare the StoragePushConstant16 capability.
storageInputOutput16 specifies whether objects in the Input and Output storage classes can have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or 16-bit floating-point members must not be used in such objects. This also specifies whether shader modules can declare the StorageInputOutput16 capability.
multiview specifies whether the implementation supports multiview rendering within a render pass. If this feature is not enabled, the view mask of each subpass must always be zero.
multiviewGeometryShader specifies whether the implementation supports multiview rendering within a render pass, with geometry shaders. If this feature is not enabled, then a pipeline compiled against a subpass with a non-zero view mask must not include a geometry shader.
multiviewTessellationShader specifies whether the implementation supports multiview rendering within a render pass, with tessellation shaders. If this feature is not enabled, then a pipeline compiled against a subpass with a non-zero view mask must not include any tessellation shaders.
variablePointersStorageBuffer specifies whether the implementation supports the SPIR-V VariablePointersStorageBuffer capability. When this feature is not enabled, shader modules must not declare the SPV_KHR_variable_pointers extension or the VariablePointersStorageBuffer capability.
variablePointers specifies whether the implementation supports the SPIR-V VariablePointers capability. When this feature is not enabled, shader modules must not declare the VariablePointers capability.
protectedMemory specifies whether protected memory is supported.
samplerYcbcrConversion specifies whether the implementation supports sampler Y′C_BC_R conversion. If samplerYcbcrConversion is VK_FALSE, sampler Y′C_BC_R conversion is not supported, and samplers using sampler Y′C_BC_R conversion must not be used.
shaderDrawParameters specifies whether shader draw parameters are supported.

If the VkPhysicalDeviceVulkan11Features structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceVulkan11Features can also be used in the pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceVulkan11Features-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES

The VkPhysicalDeviceVulkan12Features structure is defined as:

typedef struct VkPhysicalDeviceVulkan12Features {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           samplerMirrorClampToEdge;
    VkBool32           drawIndirectCount;
    VkBool32           storageBuffer8BitAccess;
    VkBool32           uniformAndStorageBuffer8BitAccess;
    VkBool32           storagePushConstant8;
    VkBool32           shaderBufferInt64Atomics;
    VkBool32           shaderSharedInt64Atomics;
    VkBool32           shaderFloat16;
    VkBool32           shaderInt8;
    VkBool32           descriptorIndexing;
    VkBool32           shaderInputAttachmentArrayDynamicIndexing;
    VkBool32           shaderUniformTexelBufferArrayDynamicIndexing;
    VkBool32           shaderStorageTexelBufferArrayDynamicIndexing;
    VkBool32           shaderUniformBufferArrayNonUniformIndexing;
    VkBool32           shaderSampledImageArrayNonUniformIndexing;
    VkBool32           shaderStorageBufferArrayNonUniformIndexing;
    VkBool32           shaderStorageImageArrayNonUniformIndexing;
    VkBool32           shaderInputAttachmentArrayNonUniformIndexing;
    VkBool32           shaderUniformTexelBufferArrayNonUniformIndexing;
    VkBool32           shaderStorageTexelBufferArrayNonUniformIndexing;
    VkBool32           descriptorBindingUniformBufferUpdateAfterBind;
    VkBool32           descriptorBindingSampledImageUpdateAfterBind;
    VkBool32           descriptorBindingStorageImageUpdateAfterBind;
    VkBool32           descriptorBindingStorageBufferUpdateAfterBind;
    VkBool32           descriptorBindingUniformTexelBufferUpdateAfterBind;
    VkBool32           descriptorBindingStorageTexelBufferUpdateAfterBind;
    VkBool32           descriptorBindingUpdateUnusedWhilePending;
    VkBool32           descriptorBindingPartiallyBound;
    VkBool32           descriptorBindingVariableDescriptorCount;
    VkBool32           runtimeDescriptorArray;
    VkBool32           samplerFilterMinmax;
    VkBool32           scalarBlockLayout;
    VkBool32           imagelessFramebuffer;
    VkBool32           uniformBufferStandardLayout;
    VkBool32           shaderSubgroupExtendedTypes;
    VkBool32           separateDepthStencilLayouts;
    VkBool32           hostQueryReset;
    VkBool32           timelineSemaphore;
    VkBool32           bufferDeviceAddress;
    VkBool32           bufferDeviceAddressCaptureReplay;
    VkBool32           bufferDeviceAddressMultiDevice;
    VkBool32           vulkanMemoryModel;
    VkBool32           vulkanMemoryModelDeviceScope;
    VkBool32           vulkanMemoryModelAvailabilityVisibilityChains;
    VkBool32           shaderOutputViewportIndex;
    VkBool32           shaderOutputLayer;
    VkBool32           subgroupBroadcastDynamicId;
} VkPhysicalDeviceVulkan12Features;

The members of the VkPhysicalDeviceVulkan12Features structure describe the following features:

samplerMirrorClampToEdge indicates whether the implementation supports the VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE sampler address mode. If this feature is not enabled, the VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE sampler address mode must not be used.
drawIndirectCount indicates whether the implementation supports the vkCmdDrawIndirectCount and vkCmdDrawIndexedIndirectCount functions. If this feature is not enabled, these functions must not be used.
storageBuffer8BitAccess indicates whether objects in the StorageBuffer or PhysicalStorageBuffer storage class with the Block decoration can have 8-bit integer members. If this feature is not enabled, 8-bit integer members must not be used in such objects. This also indicates whether shader modules can declare the StorageBuffer8BitAccess capability.
uniformAndStorageBuffer8BitAccess indicates whether objects in the Uniform storage class with the Block decoration and in the StorageBuffer or PhysicalStorageBuffer storage class with the same decoration can have 8-bit integer members. If this feature is not enabled, 8-bit integer members must not be used in such objects. This also indicates whether shader modules can declare the UniformAndStorageBuffer8BitAccess capability.
storagePushConstant8 indicates whether objects in the PushConstant storage class can have 8-bit integer members. If this feature is not enabled, 8-bit integer members must not be used in such objects. This also indicates whether shader modules can declare the StoragePushConstant8 capability.
shaderBufferInt64Atomics indicates whether shaders can support 64-bit unsigned and signed integer atomic operations on buffers.
shaderSharedInt64Atomics indicates whether shaders can support 64-bit unsigned and signed integer atomic operations on shared memory.
shaderFloat16 indicates whether 16-bit floats (halfs) are supported in shader code. This also indicates whether shader modules can declare the Float16 capability. However, this only enables a subset of the storage classes that SPIR-V allows for the Float16 SPIR-V capability: Declaring and using 16-bit floats in the Private, Workgroup, and Function storage classes is enabled, while declaring them in the interface storage classes (e.g., UniformConstant, Uniform, StorageBuffer, Input, Output, and PushConstant) is not enabled.
shaderInt8 indicates whether 8-bit integers (signed and unsigned) are supported in shader code. This also indicates whether shader modules can declare the Int8 capability. However, this only enables a subset of the storage classes that SPIR-V allows for the Int8 SPIR-V capability: Declaring and using 8-bit integers in the Private, Workgroup, and Function storage classes is enabled, while declaring them in the interface storage classes (e.g., UniformConstant, Uniform, StorageBuffer, Input, Output, and PushConstant) is not enabled.
descriptorIndexing indicates whether the implementation supports the minimum set of descriptor indexing features as described in the Feature Requirements section. Enabling the descriptorIndexing member when vkCreateDevice is called does not imply the other minimum descriptor indexing features are also enabled. Those other descriptor indexing features must be enabled individually as needed by the application.
shaderInputAttachmentArrayDynamicIndexing indicates whether arrays of input attachments can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the InputAttachmentArrayDynamicIndexing capability.
shaderUniformTexelBufferArrayDynamicIndexing indicates whether arrays of uniform texel buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the UniformTexelBufferArrayDynamicIndexing capability.
shaderStorageTexelBufferArrayDynamicIndexing indicates whether arrays of storage texel buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the StorageTexelBufferArrayDynamicIndexing capability.
shaderUniformBufferArrayNonUniformIndexing indicates whether arrays of uniform buffers can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the UniformBufferArrayNonUniformIndexing capability.
shaderSampledImageArrayNonUniformIndexing indicates whether arrays of samplers or sampled images can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, or VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the SampledImageArrayNonUniformIndexing capability.
shaderStorageBufferArrayNonUniformIndexing indicates whether arrays of storage buffers can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the StorageBufferArrayNonUniformIndexing capability.
shaderStorageImageArrayNonUniformIndexing indicates whether arrays of storage images can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the StorageImageArrayNonUniformIndexing capability.
shaderInputAttachmentArrayNonUniformIndexing indicates whether arrays of input attachments can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the InputAttachmentArrayNonUniformIndexing capability.
shaderUniformTexelBufferArrayNonUniformIndexing indicates whether arrays of uniform texel buffers can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the UniformTexelBufferArrayNonUniformIndexing capability.
shaderStorageTexelBufferArrayNonUniformIndexing indicates whether arrays of storage texel buffers can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the StorageTexelBufferArrayNonUniformIndexing capability.
descriptorBindingUniformBufferUpdateAfterBind indicates whether the implementation supports updating uniform buffer descriptors after a set is bound. If this feature is not enabled, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must not be used with VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER.
descriptorBindingSampledImageUpdateAfterBind indicates whether the implementation supports updating sampled image descriptors after a set is bound. If this feature is not enabled, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must not be used with VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, or VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE.
descriptorBindingStorageImageUpdateAfterBind indicates whether the implementation supports updating storage image descriptors after a set is bound. If this feature is not enabled, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must not be used with VK_DESCRIPTOR_TYPE_STORAGE_IMAGE.
descriptorBindingStorageBufferUpdateAfterBind indicates whether the implementation supports updating storage buffer descriptors after a set is bound. If this feature is not enabled, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must not be used with VK_DESCRIPTOR_TYPE_STORAGE_BUFFER.
descriptorBindingUniformTexelBufferUpdateAfterBind indicates whether the implementation supports updating uniform texel buffer descriptors after a set is bound. If this feature is not enabled, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must not be used with VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER.
descriptorBindingStorageTexelBufferUpdateAfterBind indicates whether the implementation supports updating storage texel buffer descriptors after a set is bound. If this feature is not enabled, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must not be used with VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER.
descriptorBindingUpdateUnusedWhilePending indicates whether the implementation supports updating descriptors while the set is in use. If this feature is not enabled, VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT must not be used.
descriptorBindingPartiallyBound indicates whether the implementation supports statically using a descriptor set binding in which some descriptors are not valid. If this feature is not enabled, VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT must not be used.
descriptorBindingVariableDescriptorCount indicates whether the implementation supports descriptor sets with a variable-sized last binding. If this feature is not enabled, VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT must not be used.
runtimeDescriptorArray indicates whether the implementation supports the SPIR-V RuntimeDescriptorArray capability. If this feature is not enabled, descriptors must not be declared in runtime arrays.
samplerFilterMinmax indicates whether the implementation supports a minimum set of required formats supporting min/max filtering as defined by the filterMinmaxSingleComponentFormats property minimum requirements. If this feature is not enabled, then no VkSamplerCreateInfo pNext chain can include a VkSamplerReductionModeCreateInfo structure.
scalarBlockLayout indicates that the implementation supports the layout of resource blocks in shaders using scalar alignment.
imagelessFramebuffer indicates that the implementation supports specifying the image view for attachments at render pass begin time via VkRenderPassAttachmentBeginInfo.
uniformBufferStandardLayout indicates that the implementation supports the same layouts for uniform buffers as for storage and other kinds of buffers. See Standard Buffer Layout.
shaderSubgroupExtendedTypes is a boolean that specifies whether subgroup operations can use 8-bit integer, 16-bit integer, 64-bit integer, 16-bit floating-point, and vectors of these types in group operations with subgroup scopeif the implementation supports the types.
separateDepthStencilLayouts indicates whether the implementation supports a VkImageMemoryBarrier for a depth/stencil image with only one of VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT set, and whether VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL can be used.
hostQueryReset indicates that the implementation supports resetting queries from the host with vkResetQueryPool.
timelineSemaphore indicates whether semaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE are supported.
bufferDeviceAddress indicates that the implementation supports accessing buffer memory in shaders as storage buffers via an address queried from vkGetBufferDeviceAddress.
bufferDeviceAddressCaptureReplay indicates that the implementation supports saving and reusing buffer and device addresses, e.g. for trace capture and replay.
bufferDeviceAddressMultiDevice indicates that the implementation supports the bufferDeviceAddress feature for logical devices created with multiple physical devices. If this feature is not supported, buffer addresses must not be queried on a logical device created with more than one physical device.
vulkanMemoryModel indicates whether the Vulkan Memory Model is supported, as defined in Vulkan Memory Model. This also indicates whether shader modules can declare the VulkanMemoryModel capability.
vulkanMemoryModelDeviceScope indicates whether the Vulkan Memory Model can use Device scope synchronization. This also indicates whether shader modules can declare the VulkanMemoryModelDeviceScope capability.
vulkanMemoryModelAvailabilityVisibilityChains indicates whether the Vulkan Memory Model can use availability and visibility chains with more than one element.
shaderOutputViewportIndex indicates whether the implementation supports the ShaderViewportIndex SPIR-V capability enabling variables decorated with the ViewportIndex built-in to be exported from vertex or tessellation evaluation shaders. If this feature is not enabled, the ViewportIndex built-in decoration must not be used on outputs in vertex or tessellation evaluation shaders.
shaderOutputLayer indicates whether the implementation supports the ShaderLayer SPIR-V capability enabling variables decorated with the Layer built-in to be exported from vertex or tessellation evaluation shaders. If this feature is not enabled, the Layer built-in decoration must not be used on outputs in vertex or tessellation evaluation shaders.
If subgroupBroadcastDynamicId is VK_TRUE, the “Id” operand of OpGroupNonUniformBroadcast can be dynamically uniform within a subgroup, and the “Index” operand of OpGroupNonUniformQuadBroadcast can be dynamically uniform within the derivative group. If it is VK_FALSE, these operands must be constants.

If the VkPhysicalDeviceVulkan12Features structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceVulkan12Features can also be used in the pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceVulkan12Features-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES

The VkPhysicalDeviceVariablePointersFeatures structure is defined as:

typedef struct VkPhysicalDeviceVariablePointersFeatures {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           variablePointersStorageBuffer;
    VkBool32           variablePointers;
} VkPhysicalDeviceVariablePointersFeatures;

or the equivalent

typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeaturesKHR;

The members of the VkPhysicalDeviceVariablePointersFeatures structure describe the following features:

variablePointersStorageBuffer specifies whether the implementation supports the SPIR-V VariablePointersStorageBuffer capability. When this feature is not enabled, shader modules must not declare the SPV_KHR_variable_pointers extension or the VariablePointersStorageBuffer capability.
variablePointers specifies whether the implementation supports the SPIR-V VariablePointers capability. When this feature is not enabled, shader modules must not declare the VariablePointers capability.

If the VkPhysicalDeviceVariablePointersFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceVariablePointersFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage

VUID-VkPhysicalDeviceVariablePointersFeatures-variablePointers-01431
If variablePointers is enabled then variablePointersStorageBuffer must also be enabled.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceVariablePointersFeatures-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES

The VkPhysicalDeviceMultiviewFeatures structure is defined as:

typedef struct VkPhysicalDeviceMultiviewFeatures {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           multiview;
    VkBool32           multiviewGeometryShader;
    VkBool32           multiviewTessellationShader;
} VkPhysicalDeviceMultiviewFeatures;

or the equivalent

typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR;

The members of the VkPhysicalDeviceMultiviewFeatures structure describe the following features:

multiview specifies whether the implementation supports multiview rendering within a render pass. If this feature is not enabled, the view mask of each subpass must always be zero.
multiviewGeometryShader specifies whether the implementation supports multiview rendering within a render pass, with geometry shaders. If this feature is not enabled, then a pipeline compiled against a subpass with a non-zero view mask must not include a geometry shader.
multiviewTessellationShader specifies whether the implementation supports multiview rendering within a render pass, with tessellation shaders. If this feature is not enabled, then a pipeline compiled against a subpass with a non-zero view mask must not include any tessellation shaders.

If the VkPhysicalDeviceMultiviewFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceMultiviewFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage

VUID-VkPhysicalDeviceMultiviewFeatures-multiviewGeometryShader-00580
If multiviewGeometryShader is enabled then multiview must also be enabled.
VUID-VkPhysicalDeviceMultiviewFeatures-multiviewTessellationShader-00581
If multiviewTessellationShader is enabled then multiview must also be enabled.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceMultiviewFeatures-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES

To query 64-bit atomic support for signed and unsigned integers call vkGetPhysicalDeviceFeatures2 with a VkPhysicalDeviceShaderAtomicInt64Features structure included in the pNext chain of its pFeatures parameter.

The VkPhysicalDeviceShaderAtomicInt64Features structure is defined as:

typedef struct VkPhysicalDeviceShaderAtomicInt64Features {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shaderBufferInt64Atomics;
    VkBool32           shaderSharedInt64Atomics;
} VkPhysicalDeviceShaderAtomicInt64Features;

or the equivalent

typedef VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShaderAtomicInt64FeaturesKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.

shaderBufferInt64Atomics indicates whether shaders can support 64-bit unsigned and signed integer atomic operations on buffers.
shaderSharedInt64Atomics indicates whether shaders can support 64-bit unsigned and signed integer atomic operations on shared memory.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceShaderAtomicInt64Features-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES

To query 8-bit storage features additionally supported call vkGetPhysicalDeviceFeatures2 with a VkPhysicalDevice8BitStorageFeatures structure included in the pNext chain of its pFeatures parameter. The VkPhysicalDevice8BitStorageFeatures structure can also be included in the pNext chain of a VkDeviceCreateInfo structure, in which case it controls which additional features are enabled in the device.

The VkPhysicalDevice8BitStorageFeatures structure is defined as:

typedef struct VkPhysicalDevice8BitStorageFeatures {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           storageBuffer8BitAccess;
    VkBool32           uniformAndStorageBuffer8BitAccess;
    VkBool32           storagePushConstant8;
} VkPhysicalDevice8BitStorageFeatures;

or the equivalent

typedef VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageFeaturesKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.

storageBuffer8BitAccess indicates whether objects in the StorageBuffer or PhysicalStorageBuffer storage class with the Block decoration can have 8-bit integer members. If this feature is not enabled, 8-bit integer members must not be used in such objects. This also indicates whether shader modules can declare the StorageBuffer8BitAccess capability.
uniformAndStorageBuffer8BitAccess indicates whether objects in the Uniform storage class with the Block decoration and in the StorageBuffer or PhysicalStorageBuffer storage class with the same decoration can have 8-bit integer members. If this feature is not enabled, 8-bit integer members must not be used in such objects. This also indicates whether shader modules can declare the UniformAndStorageBuffer8BitAccess capability.
storagePushConstant8 indicates whether objects in the PushConstant storage class can have 8-bit integer members. If this feature is not enabled, 8-bit integer members must not be used in such objects. This also indicates whether shader modules can declare the StoragePushConstant8 capability.

Valid Usage (Implicit)

VUID-VkPhysicalDevice8BitStorageFeatures-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES

To query 16-bit storage features additionally supported call vkGetPhysicalDeviceFeatures2 with a VkPhysicalDevice16BitStorageFeatures structure included in the pNext chain of its pFeatures parameter. The VkPhysicalDevice16BitStorageFeatures structure can also be included in the pNext chain of a VkDeviceCreateInfo structure, in which case it controls which additional features are enabled in the device.

The VkPhysicalDevice16BitStorageFeatures structure is defined as:

typedef struct VkPhysicalDevice16BitStorageFeatures {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           storageBuffer16BitAccess;
    VkBool32           uniformAndStorageBuffer16BitAccess;
    VkBool32           storagePushConstant16;
    VkBool32           storageInputOutput16;
} VkPhysicalDevice16BitStorageFeatures;

or the equivalent

typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.

storageBuffer16BitAccess specifies whether objects in the StorageBuffer or PhysicalStorageBuffer storage class with the Block decoration can have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or 16-bit floating-point members must not be used in such objects. This also specifies whether shader modules can declare the StorageBuffer16BitAccess capability.
uniformAndStorageBuffer16BitAccess specifies whether objects in the Uniform storage class with the Block decoration and in the StorageBuffer or PhysicalStorageBuffer storage class with the same decoration can have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or 16-bit floating-point members must not be used in such objects. This also specifies whether shader modules can declare the UniformAndStorageBuffer16BitAccess capability.
storagePushConstant16 specifies whether objects in the PushConstant storage class can have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or floating-point members must not be used in such objects. This also specifies whether shader modules can declare the StoragePushConstant16 capability.
storageInputOutput16 specifies whether objects in the Input and Output storage classes can have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or 16-bit floating-point members must not be used in such objects. This also specifies whether shader modules can declare the StorageInputOutput16 capability.

Valid Usage (Implicit)

VUID-VkPhysicalDevice16BitStorageFeatures-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES

To query features additionally supported by the [VK_KHR_shader_float16_int8] extension, call vkGetPhysicalDeviceFeatures2KHR with a VkPhysicalDeviceShaderFloat16Int8Features structure included in the pNext chain. The VkPhysicalDeviceShaderFloat16Int8Features structure can also be included in the pNext chain of a VkDeviceCreateInfo structure, in which case it controls which additional features are enabled in the device.

The VkPhysicalDeviceShaderFloat16Int8Features structure is defined as:

typedef struct VkPhysicalDeviceShaderFloat16Int8Features {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shaderFloat16;
    VkBool32           shaderInt8;
} VkPhysicalDeviceShaderFloat16Int8Features;

or the equivalent

typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.

shaderFloat16 indicates whether 16-bit floats (halfs) are supported in shader code. This also indicates whether shader modules can declare the Float16 capability. However, this only enables a subset of the storage classes that SPIR-V allows for the Float16 SPIR-V capability: Declaring and using 16-bit floats in the Private, Workgroup, and Function storage classes is enabled, while declaring them in the interface storage classes (e.g., UniformConstant, Uniform, StorageBuffer, Input, Output, and PushConstant) is not enabled.
shaderInt8 indicates whether 8-bit integers (signed and unsigned) are supported in shader code. This also indicates whether shader modules can declare the Int8 capability. However, this only enables a subset of the storage classes that SPIR-V allows for the Int8 SPIR-V capability: Declaring and using 8-bit integers in the Private, Workgroup, and Function storage classes is enabled, while declaring them in the interface storage classes (e.g., UniformConstant, Uniform, StorageBuffer, Input, Output, and PushConstant) is not enabled.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceShaderFloat16Int8Features-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES

To query shader clock support, call vkGetPhysicalDeviceFeatures2 with a VkPhysicalDeviceShaderClockFeaturesKHR structure included in the pNext chain of its pFeatures parameter.

The VkPhysicalDeviceShaderClockFeaturesKHR structure is defined as:

typedef struct VkPhysicalDeviceShaderClockFeaturesKHR {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shaderSubgroupClock;
    VkBool32           shaderDeviceClock;
} VkPhysicalDeviceShaderClockFeaturesKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
shaderSubgroupClock indicates whether shaders can support Subgroup scoped clock reads.
shaderDeviceClock indicates whether shaders can support Device scoped clock reads.

If the VkPhysicalDeviceShaderClockFeaturesKHR structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceShaderClockFeaturesKHR can also be included in the pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceShaderClockFeaturesKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR

The VkPhysicalDeviceSamplerYcbcrConversionFeatures structure is defined as:

typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           samplerYcbcrConversion;
} VkPhysicalDeviceSamplerYcbcrConversionFeatures;

or the equivalent

typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR;

The members of the VkPhysicalDeviceSamplerYcbcrConversionFeatures structure describe the following feature:

samplerYcbcrConversion specifies whether the implementation supports sampler Y′C_BC_R conversion. If samplerYcbcrConversion is VK_FALSE, sampler Y′C_BC_R conversion is not supported, and samplers using sampler Y′C_BC_R conversion must not be used.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceSamplerYcbcrConversionFeatures-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES

The VkPhysicalDeviceProtectedMemoryFeatures structure is defined as:

typedef struct VkPhysicalDeviceProtectedMemoryFeatures {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           protectedMemory;
} VkPhysicalDeviceProtectedMemoryFeatures;

protectedMemory specifies whether protected memory is supported.

If the VkPhysicalDeviceProtectedMemoryFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with a value indicating whether the feature is supported.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceProtectedMemoryFeatures-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES

The VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           advancedBlendCoherentOperations;
} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;

The members of the VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT structure describe the following features:

advancedBlendCoherentOperations specifies whether blending using advanced blend operations is guaranteed to execute atomically and in primitive order. If this is VK_TRUE, VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT is treated the same as VK_ACCESS_COLOR_ATTACHMENT_READ_BIT, and advanced blending needs no additional synchronization over basic blending. If this is VK_FALSE, then memory dependencies are required to guarantee order between two advanced blending operations that occur on the same sample.

If the VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT

The VkPhysicalDeviceConditionalRenderingFeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           conditionalRendering;
    VkBool32           inheritedConditionalRendering;
} VkPhysicalDeviceConditionalRenderingFeaturesEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
conditionalRendering specifies whether conditional rendering is supported.
inheritedConditionalRendering specifies whether a secondary command buffer can be executed while conditional rendering is active in the primary command buffer.

If the VkPhysicalDeviceConditionalRenderingFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating the implementation-dependent behavior. VkPhysicalDeviceConditionalRenderingFeaturesEXT can also be included in pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceConditionalRenderingFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT

The VkPhysicalDeviceShaderDrawParametersFeatures structure is defined as:

typedef struct VkPhysicalDeviceShaderDrawParametersFeatures {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shaderDrawParameters;
} VkPhysicalDeviceShaderDrawParametersFeatures;

shaderDrawParameters specifies whether shader draw parameters are supported.

If the VkPhysicalDeviceShaderDrawParametersFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with a value indicating whether the feature is supported.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceShaderDrawParametersFeatures-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES

The VkPhysicalDeviceMeshShaderFeaturesNV structure is defined as:

typedef struct VkPhysicalDeviceMeshShaderFeaturesNV {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           taskShader;
    VkBool32           meshShader;
} VkPhysicalDeviceMeshShaderFeaturesNV;

taskShader indicates whether the task shader stage is supported.
meshShader indicates whether the mesh shader stage is supported.

If the VkPhysicalDeviceMeshShaderFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with a value indicating whether the feature is supported. VkPhysicalDeviceMeshShaderFeaturesNV can also be included in pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceMeshShaderFeaturesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV

The VkPhysicalDeviceDescriptorIndexingFeatures structure is defined as:

typedef struct VkPhysicalDeviceDescriptorIndexingFeatures {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shaderInputAttachmentArrayDynamicIndexing;
    VkBool32           shaderUniformTexelBufferArrayDynamicIndexing;
    VkBool32           shaderStorageTexelBufferArrayDynamicIndexing;
    VkBool32           shaderUniformBufferArrayNonUniformIndexing;
    VkBool32           shaderSampledImageArrayNonUniformIndexing;
    VkBool32           shaderStorageBufferArrayNonUniformIndexing;
    VkBool32           shaderStorageImageArrayNonUniformIndexing;
    VkBool32           shaderInputAttachmentArrayNonUniformIndexing;
    VkBool32           shaderUniformTexelBufferArrayNonUniformIndexing;
    VkBool32           shaderStorageTexelBufferArrayNonUniformIndexing;
    VkBool32           descriptorBindingUniformBufferUpdateAfterBind;
    VkBool32           descriptorBindingSampledImageUpdateAfterBind;
    VkBool32           descriptorBindingStorageImageUpdateAfterBind;
    VkBool32           descriptorBindingStorageBufferUpdateAfterBind;
    VkBool32           descriptorBindingUniformTexelBufferUpdateAfterBind;
    VkBool32           descriptorBindingStorageTexelBufferUpdateAfterBind;
    VkBool32           descriptorBindingUpdateUnusedWhilePending;
    VkBool32           descriptorBindingPartiallyBound;
    VkBool32           descriptorBindingVariableDescriptorCount;
    VkBool32           runtimeDescriptorArray;
} VkPhysicalDeviceDescriptorIndexingFeatures;

or the equivalent

typedef VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescriptorIndexingFeaturesEXT;

The members of the VkPhysicalDeviceDescriptorIndexingFeatures structure describe the following features:

shaderInputAttachmentArrayDynamicIndexing indicates whether arrays of input attachments can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the InputAttachmentArrayDynamicIndexing capability.
shaderUniformTexelBufferArrayDynamicIndexing indicates whether arrays of uniform texel buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the UniformTexelBufferArrayDynamicIndexing capability.
shaderStorageTexelBufferArrayDynamicIndexing indicates whether arrays of storage texel buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the StorageTexelBufferArrayDynamicIndexing capability.
shaderUniformBufferArrayNonUniformIndexing indicates whether arrays of uniform buffers can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the UniformBufferArrayNonUniformIndexing capability.
shaderSampledImageArrayNonUniformIndexing indicates whether arrays of samplers or sampled images can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, or VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the SampledImageArrayNonUniformIndexing capability.
shaderStorageBufferArrayNonUniformIndexing indicates whether arrays of storage buffers can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the StorageBufferArrayNonUniformIndexing capability.
shaderStorageImageArrayNonUniformIndexing indicates whether arrays of storage images can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the StorageImageArrayNonUniformIndexing capability.
shaderInputAttachmentArrayNonUniformIndexing indicates whether arrays of input attachments can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the InputAttachmentArrayNonUniformIndexing capability.
shaderUniformTexelBufferArrayNonUniformIndexing indicates whether arrays of uniform texel buffers can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the UniformTexelBufferArrayNonUniformIndexing capability.
shaderStorageTexelBufferArrayNonUniformIndexing indicates whether arrays of storage texel buffers can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the StorageTexelBufferArrayNonUniformIndexing capability.
descriptorBindingUniformBufferUpdateAfterBind indicates whether the implementation supports updating uniform buffer descriptors after a set is bound. If this feature is not enabled, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must not be used with VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER.
descriptorBindingSampledImageUpdateAfterBind indicates whether the implementation supports updating sampled image descriptors after a set is bound. If this feature is not enabled, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must not be used with VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, or VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE.
descriptorBindingStorageImageUpdateAfterBind indicates whether the implementation supports updating storage image descriptors after a set is bound. If this feature is not enabled, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must not be used with VK_DESCRIPTOR_TYPE_STORAGE_IMAGE.
descriptorBindingStorageBufferUpdateAfterBind indicates whether the implementation supports updating storage buffer descriptors after a set is bound. If this feature is not enabled, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must not be used with VK_DESCRIPTOR_TYPE_STORAGE_BUFFER.
descriptorBindingUniformTexelBufferUpdateAfterBind indicates whether the implementation supports updating uniform texel buffer descriptors after a set is bound. If this feature is not enabled, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must not be used with VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER.
descriptorBindingStorageTexelBufferUpdateAfterBind indicates whether the implementation supports updating storage texel buffer descriptors after a set is bound. If this feature is not enabled, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must not be used with VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER.
descriptorBindingUpdateUnusedWhilePending indicates whether the implementation supports updating descriptors while the set is in use. If this feature is not enabled, VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT must not be used.
descriptorBindingPartiallyBound indicates whether the implementation supports statically using a descriptor set binding in which some descriptors are not valid. If this feature is not enabled, VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT must not be used.
descriptorBindingVariableDescriptorCount indicates whether the implementation supports descriptor sets with a variable-sized last binding. If this feature is not enabled, VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT must not be used.
runtimeDescriptorArray indicates whether the implementation supports the SPIR-V RuntimeDescriptorArray capability. If this feature is not enabled, descriptors must not be declared in runtime arrays.

If the VkPhysicalDeviceDescriptorIndexingFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceDescriptorIndexingFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceDescriptorIndexingFeatures-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES

The VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           vertexAttributeInstanceRateDivisor;
    VkBool32           vertexAttributeInstanceRateZeroDivisor;
} VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
vertexAttributeInstanceRateDivisor specifies whether vertex attribute fetching may be repeated in case of instanced rendering.
vertexAttributeInstanceRateZeroDivisor specifies whether a zero value for VkVertexInputBindingDivisorDescriptionEXT::divisor is supported.

If the VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating the implementation-dependent behavior. VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT can also be included in pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT

The VkPhysicalDeviceASTCDecodeFeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           decodeModeSharedExponent;
} VkPhysicalDeviceASTCDecodeFeaturesEXT;

The members of the VkPhysicalDeviceASTCDecodeFeaturesEXT structure describe the following features:

decodeModeSharedExponent indicates whether the implementation supports decoding ASTC compressed formats to VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 internal precision.

If the VkPhysicalDeviceASTCDecodeFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceASTCDecodeFeaturesEXT can also be included in the pNext chain of vkCreateDevice to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceASTCDecodeFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT

The VkPhysicalDeviceTransformFeedbackFeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           transformFeedback;
    VkBool32           geometryStreams;
} VkPhysicalDeviceTransformFeedbackFeaturesEXT;

The members of the VkPhysicalDeviceTransformFeedbackFeaturesEXT structure describe the following features:

transformFeedback indicates whether the implementation supports transform feedback and shader modules can declare the TransformFeedback capability.
geometryStreams indicates whether the implementation supports the GeometryStreams SPIR-V capability.

If the VkPhysicalDeviceTransformFeedbackFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceTransformFeedbackFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceTransformFeedbackFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT

To query memory model features additionally supported call vkGetPhysicalDeviceFeatures2 with a VkPhysicalDeviceVulkanMemoryModelFeatures structure included in the pNext chain of its pFeatures parameter. The VkPhysicalDeviceVulkanMemoryModelFeatures structure can also be included in the pNext chain of a VkDeviceCreateInfo structure, in which case it controls which additional features are enabled in the device.

The VkPhysicalDeviceVulkanMemoryModelFeatures structure is defined as:

typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           vulkanMemoryModel;
    VkBool32           vulkanMemoryModelDeviceScope;
    VkBool32           vulkanMemoryModelAvailabilityVisibilityChains;
} VkPhysicalDeviceVulkanMemoryModelFeatures;

or the equivalent

typedef VkPhysicalDeviceVulkanMemoryModelFeatures VkPhysicalDeviceVulkanMemoryModelFeaturesKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.

vulkanMemoryModel indicates whether the Vulkan Memory Model is supported, as defined in Vulkan Memory Model. This also indicates whether shader modules can declare the VulkanMemoryModel capability.
vulkanMemoryModelDeviceScope indicates whether the Vulkan Memory Model can use Device scope synchronization. This also indicates whether shader modules can declare the VulkanMemoryModelDeviceScope capability.
vulkanMemoryModelAvailabilityVisibilityChains indicates whether the Vulkan Memory Model can use availability and visibility chains with more than one element.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceVulkanMemoryModelFeatures-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES

The VkPhysicalDeviceInlineUniformBlockFeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceInlineUniformBlockFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           inlineUniformBlock;
    VkBool32           descriptorBindingInlineUniformBlockUpdateAfterBind;
} VkPhysicalDeviceInlineUniformBlockFeaturesEXT;

The members of the VkPhysicalDeviceInlineUniformBlockFeaturesEXT structure describe the following features:

inlineUniformBlock indicates whether the implementation supports inline uniform block descriptors. If this feature is not enabled, VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT must not be used.
descriptorBindingInlineUniformBlockUpdateAfterBind indicates whether the implementation supports updating inline uniform block descriptors after a set is bound. If this feature is not enabled, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must not be used with VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT.

If the VkPhysicalDeviceInlineUniformBlockFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceInlineUniformBlockFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceInlineUniformBlockFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT

The VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV structure is defined as:

typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           representativeFragmentTest;
} VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV;

The members of the VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV structure describe the following features:

representativeFragmentTest indicates whether the implementation supports the representative fragment test. See Representative Fragment Test.

If the VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV

The VkPhysicalDeviceExclusiveScissorFeaturesNV structure is defined as:

typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           exclusiveScissor;
} VkPhysicalDeviceExclusiveScissorFeaturesNV;

The members of the VkPhysicalDeviceExclusiveScissorFeaturesNV structure describe the following features:

exclusiveScissor indicates that the implementation supports the exclusive scissor test.

See Exclusive Scissor Test for more information.

If the VkPhysicalDeviceExclusiveScissorFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceExclusiveScissorFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceExclusiveScissorFeaturesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV

The VkPhysicalDeviceCornerSampledImageFeaturesNV structure is defined as:

typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           cornerSampledImage;
} VkPhysicalDeviceCornerSampledImageFeaturesNV;

The members of the VkPhysicalDeviceCornerSampledImageFeaturesNV structure describe the following features:

cornerSampledImage specifies whether images can be created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV. See Corner-Sampled Images.

If the VkPhysicalDeviceCornerSampledImageFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceCornerSampledImageFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceCornerSampledImageFeaturesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV

The VkPhysicalDeviceComputeShaderDerivativesFeaturesNV structure is defined as:

typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           computeDerivativeGroupQuads;
    VkBool32           computeDerivativeGroupLinear;
} VkPhysicalDeviceComputeShaderDerivativesFeaturesNV;

The members of the VkPhysicalDeviceComputeShaderDerivativesFeaturesNV structure describe the following features:

computeDerivativeGroupQuads indicates that the implementation supports the ComputeDerivativeGroupQuadsNV SPIR-V capability.
computeDerivativeGroupLinear indicates that the implementation supports the ComputeDerivativeGroupLinearNV SPIR-V capability.

See Compute Shader Derivatives for more information.

If the VkPhysicalDeviceComputeShaderDerivativesFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceComputeShaderDerivativesFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceComputeShaderDerivativesFeaturesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV

The VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV structure is defined as:

typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           fragmentShaderBarycentric;
} VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV;

The members of the VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV structure describe the following features:

fragmentShaderBarycentric indicates that the implementation supports the BaryCoordNV and BaryCoordNoPerspNV SPIR-V fragment shader built-ins and supports the PerVertexNV SPIR-V decoration on fragment shader input variables.

See Barycentric Interpolation for more information.

If the VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV

The VkPhysicalDeviceShaderImageFootprintFeaturesNV structure is defined as:

typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           imageFootprint;
} VkPhysicalDeviceShaderImageFootprintFeaturesNV;

imageFootprint specifies whether the implementation supports the ImageFootprintNV SPIR-V capability.

See Texel Footprint Evaluation for more information.

If the VkPhysicalDeviceShaderImageFootprintFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceShaderImageFootprintFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceShaderImageFootprintFeaturesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV

The VkPhysicalDeviceShadingRateImageFeaturesNV structure is defined as:

typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shadingRateImage;
    VkBool32           shadingRateCoarseSampleOrder;
} VkPhysicalDeviceShadingRateImageFeaturesNV;

The members of the VkPhysicalDeviceShadingRateImageFeaturesNV structure describe the following features:

shadingRateImage indicates that the implementation supports the use of a shading rate image to derive an effective shading rate for fragment processing. It also indicates that the implementation supports the ShadingRateNV SPIR-V execution mode.
shadingRateCoarseSampleOrder indicates that the implementation supports a user-configurable ordering of coverage samples in fragments larger than one pixel.

See Shading Rate Image for more information.

If the VkPhysicalDeviceShadingRateImageFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceShadingRateImageFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceShadingRateImageFeaturesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV

The VkPhysicalDeviceFragmentDensityMapFeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           fragmentDensityMap;
    VkBool32           fragmentDensityMapDynamic;
    VkBool32           fragmentDensityMapNonSubsampledImages;
} VkPhysicalDeviceFragmentDensityMapFeaturesEXT;

The members of the VkPhysicalDeviceFragmentDensityMapFeaturesEXT structure describe the following features:

fragmentDensityMap specifies whether the implementation supports render passes with a fragment density map attachment. If this feature is not enabled and the pNext chain of VkRenderPassCreateInfo includes a VkRenderPassFragmentDensityMapCreateInfoEXT structure, fragmentDensityMapAttachment must be VK_ATTACHMENT_UNUSED.
fragmentDensityMapDynamic specifies whether the implementation supports dynamic fragment density map image views. If this feature is not enabled, VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT must not be included in VkImageViewCreateInfo::flags.
fragmentDensityMapNonSubsampledImages specifies whether the implementation supports regular non-subsampled image attachments with fragment density map render passes. If this feature is not enabled, render passes with a fragment density map attachment must only have subsampled attachments bound.

If the VkPhysicalDeviceFragmentDensityMapFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceFragmentDensityMapFeaturesEXT can also be included in pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceFragmentDensityMapFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT

The VkPhysicalDeviceScalarBlockLayoutFeatures structure is defined as:

typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           scalarBlockLayout;
} VkPhysicalDeviceScalarBlockLayoutFeatures;

or the equivalent

typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeaturesEXT;

The members of the VkPhysicalDeviceScalarBlockLayoutFeatures structure describe the following features:

scalarBlockLayout indicates that the implementation supports the layout of resource blocks in shaders using scalar alignment.

If the VkPhysicalDeviceScalarBlockLayoutFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceScalarBlockLayoutFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable this feature.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceScalarBlockLayoutFeatures-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES

The VkPhysicalDeviceUniformBufferStandardLayoutFeatures structure is defined as:

typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           uniformBufferStandardLayout;
} VkPhysicalDeviceUniformBufferStandardLayoutFeatures;

or the equivalent

typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;

The members of the VkPhysicalDeviceUniformBufferStandardLayoutFeatures structure describe the following features:

uniformBufferStandardLayout indicates that the implementation supports the same layouts for uniform buffers as for storage and other kinds of buffers. See Standard Buffer Layout.

If the VkPhysicalDeviceUniformBufferStandardLayoutFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceUniformBufferStandardLayoutFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable this feature.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceUniformBufferStandardLayoutFeatures-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES

The VkPhysicalDeviceDepthClipEnableFeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           depthClipEnable;
} VkPhysicalDeviceDepthClipEnableFeaturesEXT;

The members of the VkPhysicalDeviceDepthClipEnableFeaturesEXT structure describe the following features:

depthClipEnable indicates that the implementation supports setting the depth clipping operation explicitly via the VkPipelineRasterizationDepthClipStateCreateInfoEXT pipeline state. Otherwise depth clipping is only enabled when VkPipelineRasterizationStateCreateInfo::depthClampEnable is set to VK_FALSE.

If the VkPhysicalDeviceDepthClipEnableFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceDepthClipEnableFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable this feature.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceDepthClipEnableFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT

The VkPhysicalDeviceMemoryPriorityFeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           memoryPriority;
} VkPhysicalDeviceMemoryPriorityFeaturesEXT;

The members of the VkPhysicalDeviceMemoryPriorityFeaturesEXT structure describe the following features:

memoryPriority indicates that the implementation supports memory priorities specified at memory allocation time via VkMemoryPriorityAllocateInfoEXT.

If the VkPhysicalDeviceMemoryPriorityFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceMemoryPriorityFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceMemoryPriorityFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT

The VkPhysicalDeviceBufferDeviceAddressFeatures structure is defined as:

typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           bufferDeviceAddress;
    VkBool32           bufferDeviceAddressCaptureReplay;
    VkBool32           bufferDeviceAddressMultiDevice;
} VkPhysicalDeviceBufferDeviceAddressFeatures;

or the equivalent

typedef VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeaturesKHR;

The members of the VkPhysicalDeviceBufferDeviceAddressFeatures structure describe the following features:

bufferDeviceAddress indicates that the implementation supports accessing buffer memory in shaders as storage buffers via an address queried from vkGetBufferDeviceAddress.
bufferDeviceAddressCaptureReplay indicates that the implementation supports saving and reusing buffer and device addresses, e.g. for trace capture and replay.
bufferDeviceAddressMultiDevice indicates that the implementation supports the bufferDeviceAddress feature for logical devices created with multiple physical devices. If this feature is not supported, buffer addresses must not be queried on a logical device created with more than one physical device.

Note

bufferDeviceAddressMultiDevice exists to allow certain legacy platforms to be able to support bufferDeviceAddress without needing to support shared GPU virtual addresses for multi-device configurations.

See vkGetBufferDeviceAddress for more information.

If the VkPhysicalDeviceBufferDeviceAddressFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceBufferDeviceAddressFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceBufferDeviceAddressFeatures-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES

The VkPhysicalDeviceBufferDeviceAddressFeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           bufferDeviceAddress;
    VkBool32           bufferDeviceAddressCaptureReplay;
    VkBool32           bufferDeviceAddressMultiDevice;
} VkPhysicalDeviceBufferDeviceAddressFeaturesEXT;

The members of the VkPhysicalDeviceBufferDeviceAddressFeaturesEXT structure describe the following features:

bufferDeviceAddress indicates that the implementation supports accessing buffer memory in shaders as storage buffers via an address queried from vkGetBufferDeviceAddressEXT.
bufferDeviceAddressCaptureReplay indicates that the implementation supports saving and reusing buffer addresses, e.g. for trace capture and replay.
bufferDeviceAddressMultiDevice indicates that the implementation supports the bufferDeviceAddress feature for logical devices created with multiple physical devices. If this feature is not supported, buffer addresses must not be queried on a logical device created with more than one physical device.

If the VkPhysicalDeviceBufferDeviceAddressFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceBufferDeviceAddressFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Note

The VkPhysicalDeviceBufferDeviceAddressFeaturesEXT structure has the same members as the VkPhysicalDeviceBufferDeviceAddressFeatures structure, but the functionality indicated by the members is expressed differently. The features indicated by the VkPhysicalDeviceBufferDeviceAddressFeatures structure requires additional flags to be passed at memory allocation time, and the capture and replay mechanism is built around opaque capture addresses for buffer and memory objects.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceBufferDeviceAddressFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT

The VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV structure is defined as:

typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           dedicatedAllocationImageAliasing;
} VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;

The members of the VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV structure describe the following features:

dedicatedAllocationImageAliasing indicates that the implementation supports aliasing of compatible image objects on a dedicated allocation.

If the VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV

The VkPhysicalDeviceImagelessFramebufferFeatures structure is defined as:

typedef struct VkPhysicalDeviceImagelessFramebufferFeatures {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           imagelessFramebuffer;
} VkPhysicalDeviceImagelessFramebufferFeatures;

or the equivalent

typedef VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeaturesKHR;

The members of the VkPhysicalDeviceImagelessFramebufferFeatures structure describe the following features:

imagelessFramebuffer indicates that the implementation supports specifying the image view for attachments at render pass begin time via VkRenderPassAttachmentBeginInfo.

If the VkPhysicalDeviceImagelessFramebufferFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceImagelessFramebufferFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable this feature.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceImagelessFramebufferFeatures-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES

The VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           fragmentShaderSampleInterlock;
    VkBool32           fragmentShaderPixelInterlock;
    VkBool32           fragmentShaderShadingRateInterlock;
} VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT;

The members of the VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT structure describe the following features:

fragmentShaderSampleInterlock indicates that the implementation supports the FragmentShaderSampleInterlockEXT SPIR-V capability.
fragmentShaderPixelInterlock indicates that the implementation supports the FragmentShaderPixelInterlockEXT SPIR-V capability.
fragmentShaderShadingRateInterlock indicates that the implementation supports the FragmentShaderShadingRateInterlockEXT SPIR-V capability.

If the VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT

The VkPhysicalDeviceCooperativeMatrixFeaturesNV structure is defined as:

typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           cooperativeMatrix;
    VkBool32           cooperativeMatrixRobustBufferAccess;
} VkPhysicalDeviceCooperativeMatrixFeaturesNV;

The members of the VkPhysicalDeviceCooperativeMatrixFeaturesNV structure describe the following features:

cooperativeMatrix indicates that the implementation supports the CooperativeMatrixNV SPIR-V capability.
cooperativeMatrixRobustBufferAccess indicates that the implementation supports robust buffer access for SPIR-V OpCooperativeMatrixLoadNV and OpCooperativeMatrixStoreNV instructions.

If the VkPhysicalDeviceCooperativeMatrixFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceCooperativeMatrixFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceCooperativeMatrixFeaturesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV

The VkPhysicalDeviceYcbcrImageArraysFeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           ycbcrImageArrays;
} VkPhysicalDeviceYcbcrImageArraysFeaturesEXT;

The members of the VkPhysicalDeviceYcbcrImageArraysFeaturesEXT structure describe the following features:

ycbcrImageArrays indicates that the implementation supports creating images with a format that requires Y′C_BC_R conversion and has multiple array layers.

If the VkPhysicalDeviceYcbcrImageArraysFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceYcbcrImageArraysFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceYcbcrImageArraysFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT

The VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures structure is defined as:

typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shaderSubgroupExtendedTypes;
} VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures;

or the equivalent

typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;

The members of the VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures structure describe the following features:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.

shaderSubgroupExtendedTypes is a boolean that specifies whether subgroup operations can use 8-bit integer, 16-bit integer, 64-bit integer, 16-bit floating-point, and vectors of these types in group operations with subgroup scopeif the implementation supports the types.

If the VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES

The VkPhysicalDeviceHostQueryResetFeatures structure is defined as:

typedef struct VkPhysicalDeviceHostQueryResetFeatures {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           hostQueryReset;
} VkPhysicalDeviceHostQueryResetFeatures;

or the equivalent

typedef VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFeaturesEXT;

The members of the VkPhysicalDeviceHostQueryResetFeatures structure describe the following features:

hostQueryReset indicates that the implementation supports resetting queries from the host with vkResetQueryPool.

If the VkPhysicalDeviceHostQueryResetFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceHostQueryResetFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceHostQueryResetFeatures-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES

The VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL structure is defined as:

typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shaderIntegerFunctions2;
} VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;

The members of the VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL structure describe the following features:

shaderIntegerFunctions2 indicates that the implementation supports the ShaderIntegerFunctions2INTEL SPIR-V capability.

If the VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL

The VkPhysicalDeviceCoverageReductionModeFeaturesNV structure is defined as:

typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           coverageReductionMode;
} VkPhysicalDeviceCoverageReductionModeFeaturesNV;

The members of the VkPhysicalDeviceCoverageReductionModeFeaturesNV structure describe the following features:

coverageReductionMode indicates whether the implementation supports coverage reduction modes. See Coverage Reduction.

If the VkPhysicalDeviceCoverageReductionModeFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceCoverageReductionModeFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceCoverageReductionModeFeaturesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV

The VkPhysicalDeviceTimelineSemaphoreFeatures structure is defined as:

typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           timelineSemaphore;
} VkPhysicalDeviceTimelineSemaphoreFeatures;

or the equivalent

typedef VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimelineSemaphoreFeaturesKHR;

The members of the VkPhysicalDeviceTimelineSemaphoreFeatures structure describe the following features:

timelineSemaphore indicates whether semaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE are supported.

If the VkPhysicalDeviceTimelineSemaphoreFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceTimelineSemaphoreFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceTimelineSemaphoreFeatures-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES

The VkPhysicalDeviceIndexTypeUint8FeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           indexTypeUint8;
} VkPhysicalDeviceIndexTypeUint8FeaturesEXT;

The members of the VkPhysicalDeviceIndexTypeUint8FeaturesEXT structure describe the following features:

indexTypeUint8 indicates that VK_INDEX_TYPE_UINT8_EXT can be used with vkCmdBindIndexBuffer.

If the VkPhysicalDeviceIndexTypeUint8FeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceIndexTypeUint8FeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceIndexTypeUint8FeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT

The VkPhysicalDeviceShaderSMBuiltinsFeaturesNV structure is defined as:

typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shaderSMBuiltins;
} VkPhysicalDeviceShaderSMBuiltinsFeaturesNV;

The members of the VkPhysicalDeviceShaderSMBuiltinsFeaturesNV structure describe the following features:

shaderSMBuiltins indicates whether the implementation supports the SPIR-V ShaderSMBuiltinsNV capability.

If the VkPhysicalDeviceShaderSMBuiltinsFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceShaderSMBuiltinsFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceShaderSMBuiltinsFeaturesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV

The VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures structure is defined as:

typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           separateDepthStencilLayouts;
} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures;

or the equivalent

typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;

The members of the VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures structure describe the following features:

separateDepthStencilLayouts indicates whether the implementation supports a VkImageMemoryBarrier for a depth/stencil image with only one of VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT set, and whether VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL can be used.

If the VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES

The VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR structure is defined as:

typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           pipelineExecutableInfo;
} VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR;

The members of the VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR structure describe the following features:

pipelineExecutableInfo indicates that the implementation supports reporting properties and statistics about the executables associated with a compiled pipeline.

If the VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR

The VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shaderDemoteToHelperInvocation;
} VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;

The members of the VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT structure describe the following features:

shaderDemoteToHelperInvocation indicates whether the implementation supports the SPIR-V DemoteToHelperInvocationEXT capability.

If the VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT

The VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           texelBufferAlignment;
} VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT;

The members of the VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT structure describe the following features:

texelBufferAlignment indicates whether the implementation uses more specific alignment requirements advertised in VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT rather than VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment.

If the VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT

The VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           textureCompressionASTC_HDR;
} VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;

The members of the VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT structure describe the following features:

textureCompressionASTC_HDR indicates whether all of the ASTC HDR compressed texture formats are supported. If this feature is enabled, then the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, VK_FORMAT_FEATURE_BLIT_SRC_BIT and VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT features must be supported in optimalTilingFeatures for the following formats:
- VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT
- VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT
- VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT
- VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT
- VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT
- VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT
- VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT
- VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT
- VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT
- VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT
- VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT
- VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT
- VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT
- VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT
To query for additional properties, or if the feature is not enabled, vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats as normal.

If the VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT can also be included in the pNext chain of vkCreateDevice to enable features.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT

The VkPhysicalDeviceLineRasterizationFeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           rectangularLines;
    VkBool32           bresenhamLines;
    VkBool32           smoothLines;
    VkBool32           stippledRectangularLines;
    VkBool32           stippledBresenhamLines;
    VkBool32           stippledSmoothLines;
} VkPhysicalDeviceLineRasterizationFeaturesEXT;

The members of the VkPhysicalDeviceLineRasterizationFeaturesEXT structure describe the following features:

rectangularLines indicates whether the implementation supports rectangular line rasterization.
bresenhamLines indicates whether the implementation supports Bresenham-style line rasterization.
smoothLines indicates whether the implementation supports smooth line rasterization.
stippledRectangularLines indicates whether the implementation supports stippled line rasterization with VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT lines, or with VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT lines if VkPhysicalDeviceLimits::strictLines is VK_TRUE.
stippledBresenhamLines indicates whether the implementation supports stippled line rasterization with VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT lines.
stippledSmoothLines indicates whether the implementation supports stippled line rasterization with VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT lines.

If the VkPhysicalDeviceLineRasterizationFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceLineRasterizationFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceLineRasterizationFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT

The VkPhysicalDeviceSubgroupSizeControlFeaturesEXT structure is defined as:

typedef struct VkPhysicalDeviceSubgroupSizeControlFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           subgroupSizeControl;
    VkBool32           computeFullSubgroups;
} VkPhysicalDeviceSubgroupSizeControlFeaturesEXT;

The members of the VkPhysicalDeviceSubgroupSizeControlFeaturesEXT structure describe the following features:

subgroupSizeControl indicates whether the implementation supports controlling shader subgroup sizes via the VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT flag and the VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure.
computeFullSubgroups indicates whether the implementation supports requiring full subgroups in compute shaders via the VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT flag.

If the VkPhysicalDeviceSubgroupSizeControlFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceSubgroupSizeControlFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

Note

The VkPhysicalDeviceSubgroupSizeControlFeaturesEXT structure was added in version 2 of the VK_EXT_subgroup_size_control extension. Version 1 implementations of this extension will not fill out the features structure but applications may assume that both subgroupSizeControl and computeFullSubgroups are supported if the extension is supported. (See also the Feature Requirements section.) Applications are advised to add a VkPhysicalDeviceSubgroupSizeControlFeaturesEXT structure to the pNext chain of VkDeviceCreateInfo to enable the features regardless of the version of the extension supported by the implementation. If the implementation only supports version 1, it will safely ignore the VkPhysicalDeviceSubgroupSizeControlFeaturesEXT structure.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceSubgroupSizeControlFeaturesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT

The VkPhysicalDeviceCoherentMemoryFeaturesAMD structure is defined as:

typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           deviceCoherentMemory;
} VkPhysicalDeviceCoherentMemoryFeaturesAMD;

The members of the VkPhysicalDeviceCoherentMemoryFeaturesAMD structure describe the following features:

deviceCoherentMemory indicates that the implementation supports device coherent memory.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceCoherentMemoryFeaturesAMD-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD

35.1. Feature Requirements

All Vulkan graphics implementations must support the following features:

robustBufferAccess
multiview, if Vulkan 1.1 is supported.
uniformBufferStandardLayout, if Vulkan 1.2 or the [VK_KHR_uniform_buffer_standard_layout] extension is supported.
variablePointersStorageBuffer, if the [VK_KHR_variable_pointers] extension is supported.
storageBuffer8BitAccess, if the [VK_KHR_8bit_storage] extension is supported.
If the descriptorIndexing feature is supported, or if the [VK_EXT_descriptor_indexing] extension is supported:
inlineUniformBlock, if the VK_EXT_inline_uniform_block extension is supported.
descriptorBindingInlineUniformBlockUpdateAfterBind, if the VK_EXT_inline_uniform_block extension is supported; and if the descriptorIndexing feature is supported, or the [VK_EXT_descriptor_indexing] extension is supported.
scalarBlockLayout, if the [VK_EXT_scalar_block_layout] extension is supported.
subgroupBroadcastDynamicId, if Vulkan 1.2 is supported.
samplerMirrorClampToEdge, if the [VK_KHR_sampler_mirror_clamp_to_edge] extension is supported.
drawIndirectCount, if the [VK_KHR_draw_indirect_count] extension is supported.
samplerFilterMinmax, if the [VK_EXT_sampler_filter_minmax] extension is supported.
shaderOutputViewportIndex, if the [VK_EXT_shader_viewport_index_layer] extension is supported.
shaderOutputLayer, if the [VK_EXT_shader_viewport_index_layer] extension is supported.
subgroupSizeControl, if the VK_EXT_subgroup_size_control extension is supported.
computeFullSubgroups, if the VK_EXT_subgroup_size_control extension is supported.
imagelessFramebuffer, if Vulkan 1.2 is supported.
separateDepthStencilLayouts, if Vulkan 1.2 is supported.
hostQueryReset, if Vulkan 1.2 is supported.
timelineSemaphore, if Vulkan 1.2 or the [VK_KHR_timeline_semaphore] extension is supported.

All other features defined in the Specification are optional.

36. Limits

Limits are implementation-dependent minimums, maximums, and other device characteristics that an application may need to be aware of.

Note

Limits are reported via the basic VkPhysicalDeviceLimits structure, as well as the extensible structure VkPhysicalDeviceProperties2, which was added in [VK_KHR_get_physical_device_properties2] and included in Vulkan 1.1. When limits are added in future Vulkan versions or extensions, each extension should introduce one new limit structure, if needed. This structure can be added to the pNext chain of the VkPhysicalDeviceProperties2 structure.

The VkPhysicalDeviceLimits structure is defined as:

typedef struct VkPhysicalDeviceLimits {
    uint32_t              maxImageDimension1D;
    uint32_t              maxImageDimension2D;
    uint32_t              maxImageDimension3D;
    uint32_t              maxImageDimensionCube;
    uint32_t              maxImageArrayLayers;
    uint32_t              maxTexelBufferElements;
    uint32_t              maxUniformBufferRange;
    uint32_t              maxStorageBufferRange;
    uint32_t              maxPushConstantsSize;
    uint32_t              maxMemoryAllocationCount;
    uint32_t              maxSamplerAllocationCount;
    VkDeviceSize          bufferImageGranularity;
    VkDeviceSize          sparseAddressSpaceSize;
    uint32_t              maxBoundDescriptorSets;
    uint32_t              maxPerStageDescriptorSamplers;
    uint32_t              maxPerStageDescriptorUniformBuffers;
    uint32_t              maxPerStageDescriptorStorageBuffers;
    uint32_t              maxPerStageDescriptorSampledImages;
    uint32_t              maxPerStageDescriptorStorageImages;
    uint32_t              maxPerStageDescriptorInputAttachments;
    uint32_t              maxPerStageResources;
    uint32_t              maxDescriptorSetSamplers;
    uint32_t              maxDescriptorSetUniformBuffers;
    uint32_t              maxDescriptorSetUniformBuffersDynamic;
    uint32_t              maxDescriptorSetStorageBuffers;
    uint32_t              maxDescriptorSetStorageBuffersDynamic;
    uint32_t              maxDescriptorSetSampledImages;
    uint32_t              maxDescriptorSetStorageImages;
    uint32_t              maxDescriptorSetInputAttachments;
    uint32_t              maxVertexInputAttributes;
    uint32_t              maxVertexInputBindings;
    uint32_t              maxVertexInputAttributeOffset;
    uint32_t              maxVertexInputBindingStride;
    uint32_t              maxVertexOutputComponents;
    uint32_t              maxTessellationGenerationLevel;
    uint32_t              maxTessellationPatchSize;
    uint32_t              maxTessellationControlPerVertexInputComponents;
    uint32_t              maxTessellationControlPerVertexOutputComponents;
    uint32_t              maxTessellationControlPerPatchOutputComponents;
    uint32_t              maxTessellationControlTotalOutputComponents;
    uint32_t              maxTessellationEvaluationInputComponents;
    uint32_t              maxTessellationEvaluationOutputComponents;
    uint32_t              maxGeometryShaderInvocations;
    uint32_t              maxGeometryInputComponents;
    uint32_t              maxGeometryOutputComponents;
    uint32_t              maxGeometryOutputVertices;
    uint32_t              maxGeometryTotalOutputComponents;
    uint32_t              maxFragmentInputComponents;
    uint32_t              maxFragmentOutputAttachments;
    uint32_t              maxFragmentDualSrcAttachments;
    uint32_t              maxFragmentCombinedOutputResources;
    uint32_t              maxComputeSharedMemorySize;
    uint32_t              maxComputeWorkGroupCount[3];
    uint32_t              maxComputeWorkGroupInvocations;
    uint32_t              maxComputeWorkGroupSize[3];
    uint32_t              subPixelPrecisionBits;
    uint32_t              subTexelPrecisionBits;
    uint32_t              mipmapPrecisionBits;
    uint32_t              maxDrawIndexedIndexValue;
    uint32_t              maxDrawIndirectCount;
    float                 maxSamplerLodBias;
    float                 maxSamplerAnisotropy;
    uint32_t              maxViewports;
    uint32_t              maxViewportDimensions[2];
    float                 viewportBoundsRange[2];
    uint32_t              viewportSubPixelBits;
    size_t                minMemoryMapAlignment;
    VkDeviceSize          minTexelBufferOffsetAlignment;
    VkDeviceSize          minUniformBufferOffsetAlignment;
    VkDeviceSize          minStorageBufferOffsetAlignment;
    int32_t               minTexelOffset;
    uint32_t              maxTexelOffset;
    int32_t               minTexelGatherOffset;
    uint32_t              maxTexelGatherOffset;
    float                 minInterpolationOffset;
    float                 maxInterpolationOffset;
    uint32_t              subPixelInterpolationOffsetBits;
    uint32_t              maxFramebufferWidth;
    uint32_t              maxFramebufferHeight;
    uint32_t              maxFramebufferLayers;
    VkSampleCountFlags    framebufferColorSampleCounts;
    VkSampleCountFlags    framebufferDepthSampleCounts;
    VkSampleCountFlags    framebufferStencilSampleCounts;
    VkSampleCountFlags    framebufferNoAttachmentsSampleCounts;
    uint32_t              maxColorAttachments;
    VkSampleCountFlags    sampledImageColorSampleCounts;
    VkSampleCountFlags    sampledImageIntegerSampleCounts;
    VkSampleCountFlags    sampledImageDepthSampleCounts;
    VkSampleCountFlags    sampledImageStencilSampleCounts;
    VkSampleCountFlags    storageImageSampleCounts;
    uint32_t              maxSampleMaskWords;
    VkBool32              timestampComputeAndGraphics;
    float                 timestampPeriod;
    uint32_t              maxClipDistances;
    uint32_t              maxCullDistances;
    uint32_t              maxCombinedClipAndCullDistances;
    uint32_t              discreteQueuePriorities;
    float                 pointSizeRange[2];
    float                 lineWidthRange[2];
    float                 pointSizeGranularity;
    float                 lineWidthGranularity;
    VkBool32              strictLines;
    VkBool32              standardSampleLocations;
    VkDeviceSize          optimalBufferCopyOffsetAlignment;
    VkDeviceSize          optimalBufferCopyRowPitchAlignment;
    VkDeviceSize          nonCoherentAtomSize;
} VkPhysicalDeviceLimits;

The VkPhysicalDeviceLimits are properties of the physical device. These are available in the limits member of the VkPhysicalDeviceProperties structure which is returned from vkGetPhysicalDeviceProperties.

maxImageDimension1D is the maximum dimension (width) supported for all images created with an imageType of VK_IMAGE_TYPE_1D.
maxImageDimension2D is the maximum dimension (width or height) supported for all images created with an imageType of VK_IMAGE_TYPE_2D and without VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT set in flags.
maxImageDimension3D is the maximum dimension (width, height, or depth) supported for all images created with an imageType of VK_IMAGE_TYPE_3D.
maxImageDimensionCube is the maximum dimension (width or height) supported for all images created with an imageType of VK_IMAGE_TYPE_2D and with VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT set in flags.
maxImageArrayLayers is the maximum number of layers (arrayLayers) for an image.
maxTexelBufferElements is the maximum number of addressable texels for a buffer view created on a buffer which was created with the VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT set in the usage member of the VkBufferCreateInfo structure.
maxUniformBufferRange is the maximum value that can be specified in the range member of any VkDescriptorBufferInfo structures passed to a call to vkUpdateDescriptorSets for descriptors of type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC.
maxStorageBufferRange is the maximum value that can be specified in the range member of any VkDescriptorBufferInfo structures passed to a call to vkUpdateDescriptorSets for descriptors of type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC.
maxPushConstantsSize is the maximum size, in bytes, of the pool of push constant memory. For each of the push constant ranges indicated by the pPushConstantRanges member of the VkPipelineLayoutCreateInfo structure, (offset + size) must be less than or equal to this limit.
maxMemoryAllocationCount is the maximum number of device memory allocations, as created by vkAllocateMemory, which can simultaneously exist.
maxSamplerAllocationCount is the maximum number of sampler objects, as created by vkCreateSampler, which can simultaneously exist on a device.
bufferImageGranularity is the granularity, in bytes, at which buffer or linear image resources, and optimal image resources can be bound to adjacent offsets in the same VkDeviceMemory object without aliasing. See Buffer-Image Granularity for more details.
sparseAddressSpaceSize is the total amount of address space available, in bytes, for sparse memory resources. This is an upper bound on the sum of the size of all sparse resources, regardless of whether any memory is bound to them.
maxBoundDescriptorSets is the maximum number of descriptor sets that can be simultaneously used by a pipeline. All DescriptorSet decorations in shader modules must have a value less than maxBoundDescriptorSets. See Descriptor Sets.
maxPerStageDescriptorSamplers is the maximum number of samplers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a shader stage when the stageFlags member of the VkDescriptorSetLayoutBinding structure has the bit for that shader stage set. See Sampler and Combined Image Sampler.
maxPerStageDescriptorUniformBuffers is the maximum number of uniform buffers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a shader stage when the stageFlags member of the VkDescriptorSetLayoutBinding structure has the bit for that shader stage set. See Uniform Buffer and Dynamic Uniform Buffer.
maxPerStageDescriptorStorageBuffers is the maximum number of storage buffers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the stageFlags member of the VkDescriptorSetLayoutBinding structure has the bit for that shader stage set. See Storage Buffer and Dynamic Storage Buffer.
maxPerStageDescriptorSampledImages is the maximum number of sampled images that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, or VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the stageFlags member of the VkDescriptorSetLayoutBinding structure has the bit for that shader stage set. See Combined Image Sampler, Sampled Image, and Uniform Texel Buffer.
maxPerStageDescriptorStorageImages is the maximum number of storage images that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the stageFlags member of the VkDescriptorSetLayoutBinding structure has the bit for that shader stage set. See Storage Image, and Storage Texel Buffer.
maxPerStageDescriptorInputAttachments is the maximum number of input attachments that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the stageFlags member of the VkDescriptorSetLayoutBinding structure has the bit for that shader stage set. These are only supported for the fragment stage. See Input Attachment.
maxPerStageResources is the maximum number of resources that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. For the fragment shader stage the framebuffer color attachments also count against this limit.
maxDescriptorSetSamplers is the maximum number of samplers that can be included in a pipeline layout. Descriptors with a type of VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See Sampler and Combined Image Sampler.
maxDescriptorSetUniformBuffers is the maximum number of uniform buffers that can be included in a pipeline layout. Descriptors with a type of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See Uniform Buffer and Dynamic Uniform Buffer.
maxDescriptorSetUniformBuffersDynamic is the maximum number of dynamic uniform buffers that can be included in a pipeline layout. Descriptors with a type of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See Dynamic Uniform Buffer.
maxDescriptorSetStorageBuffers is the maximum number of storage buffers that can be included in a pipeline layout. Descriptors with a type of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See Storage Buffer and Dynamic Storage Buffer.
maxDescriptorSetStorageBuffersDynamic is the maximum number of dynamic storage buffers that can be included in a pipeline layout. Descriptors with a type of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See Dynamic Storage Buffer.
maxDescriptorSetSampledImages is the maximum number of sampled images that can be included in a pipeline layout. Descriptors with a type of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, or VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See Combined Image Sampler, Sampled Image, and Uniform Texel Buffer.
maxDescriptorSetStorageImages is the maximum number of storage images that can be included in a pipeline layout. Descriptors with a type of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See Storage Image, and Storage Texel Buffer.
maxDescriptorSetInputAttachments is the maximum number of input attachments that can be included in a pipeline layout. Descriptors with a type of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See Input Attachment.
maxVertexInputAttributes is the maximum number of vertex input attributes that can be specified for a graphics pipeline. These are described in the array of VkVertexInputAttributeDescription structures that are provided at graphics pipeline creation time via the pVertexAttributeDescriptions member of the VkPipelineVertexInputStateCreateInfo structure. See Vertex Attributes and Vertex Input Description.
maxVertexInputBindings is the maximum number of vertex buffers that can be specified for providing vertex attributes to a graphics pipeline. These are described in the array of VkVertexInputBindingDescription structures that are provided at graphics pipeline creation time via the pVertexBindingDescriptions member of the VkPipelineVertexInputStateCreateInfo structure. The binding member of VkVertexInputBindingDescription must be less than this limit. See Vertex Input Description.
maxVertexInputAttributeOffset is the maximum vertex input attribute offset that can be added to the vertex input binding stride. The offset member of the VkVertexInputAttributeDescription structure must be less than or equal to this limit. See Vertex Input Description.
maxVertexInputBindingStride is the maximum vertex input binding stride that can be specified in a vertex input binding. The stride member of the VkVertexInputBindingDescription structure must be less than or equal to this limit. See Vertex Input Description.
maxVertexOutputComponents is the maximum number of components of output variables which can be output by a vertex shader. See Vertex Shaders.
maxTessellationGenerationLevel is the maximum tessellation generation level supported by the fixed-function tessellation primitive generator. See Tessellation.
maxTessellationPatchSize is the maximum patch size, in vertices, of patches that can be processed by the tessellation control shader and tessellation primitive generator. The patchControlPoints member of the VkPipelineTessellationStateCreateInfo structure specified at pipeline creation time and the value provided in the OutputVertices execution mode of shader modules must be less than or equal to this limit. See Tessellation.
maxTessellationControlPerVertexInputComponents is the maximum number of components of input variables which can be provided as per-vertex inputs to the tessellation control shader stage.
maxTessellationControlPerVertexOutputComponents is the maximum number of components of per-vertex output variables which can be output from the tessellation control shader stage.
maxTessellationControlPerPatchOutputComponents is the maximum number of components of per-patch output variables which can be output from the tessellation control shader stage.
maxTessellationControlTotalOutputComponents is the maximum total number of components of per-vertex and per-patch output variables which can be output from the tessellation control shader stage.
maxTessellationEvaluationInputComponents is the maximum number of components of input variables which can be provided as per-vertex inputs to the tessellation evaluation shader stage.
maxTessellationEvaluationOutputComponents is the maximum number of components of per-vertex output variables which can be output from the tessellation evaluation shader stage.
maxGeometryShaderInvocations is the maximum invocation count supported for instanced geometry shaders. The value provided in the Invocations execution mode of shader modules must be less than or equal to this limit. See Geometry Shading.
maxGeometryInputComponents is the maximum number of components of input variables which can be provided as inputs to the geometry shader stage.
maxGeometryOutputComponents is the maximum number of components of output variables which can be output from the geometry shader stage.
maxGeometryOutputVertices is the maximum number of vertices which can be emitted by any geometry shader.
maxGeometryTotalOutputComponents is the maximum total number of components of output, across all emitted vertices, which can be output from the geometry shader stage.
maxFragmentInputComponents is the maximum number of components of input variables which can be provided as inputs to the fragment shader stage.
maxFragmentOutputAttachments is the maximum number of output attachments which can be written to by the fragment shader stage.
maxFragmentDualSrcAttachments is the maximum number of output attachments which can be written to by the fragment shader stage when blending is enabled and one of the dual source blend modes is in use. See Dual-Source Blending and dualSrcBlend.
maxFragmentCombinedOutputResources is the total number of storage buffers, storage images, and output buffers which can be used in the fragment shader stage.
maxComputeSharedMemorySize is the maximum total storage size, in bytes, available for variables declared with the Workgroup storage class in shader modules (or with the shared storage qualifier in GLSL) in the compute shader stage. The amount of storage consumed by the variables declared with the Workgroup storage class is implementation-dependent. However, the amount of storage consumed may not exceed the largest block size that would be obtained if all active variables declared with Workgroup storage class were assigned offsets in an arbitrary order by successively taking the smallest valid offset according to the Standard Storage Buffer Layout rules. (This is equivalent to using the GLSL std430 layout rules.)
maxComputeWorkGroupCount[3] is the maximum number of local workgroups that can be dispatched by a single dispatch command. These three values represent the maximum number of local workgroups for the X, Y, and Z dimensions, respectively. The workgroup count parameters to the dispatch commands must be less than or equal to the corresponding limit. See Dispatching Commands.
maxComputeWorkGroupInvocations is the maximum total number of compute shader invocations in a single local workgroup. The product of the X, Y, and Z sizes, as specified by the LocalSize execution mode in shader modules or by the object decorated by the WorkgroupSize decoration, must be less than or equal to this limit.
maxComputeWorkGroupSize[3] is the maximum size of a local compute workgroup, per dimension. These three values represent the maximum local workgroup size in the X, Y, and Z dimensions, respectively. The x, y, and z sizes, as specified by the LocalSize execution mode or by the object decorated by the WorkgroupSize decoration in shader modules, must be less than or equal to the corresponding limit.
subPixelPrecisionBits is the number of bits of subpixel precision in framebuffer coordinates x_f and y_f. See Rasterization.
subTexelPrecisionBits is the number of bits of precision in the division along an axis of an image used for minification and magnification filters. 2^{subTexelPrecisionBits} is the actual number of divisions along each axis of the image represented. Sub-texel values calculated during image sampling will snap to these locations when generating the filtered results.
mipmapPrecisionBits is the number of bits of division that the LOD calculation for mipmap fetching get snapped to when determining the contribution from each mip level to the mip filtered results. 2^{mipmapPrecisionBits} is the actual number of divisions.
maxDrawIndexedIndexValue is the maximum index value that can be used for indexed draw calls when using 32-bit indices. This excludes the primitive restart index value of 0xFFFFFFFF. See fullDrawIndexUint32.
maxDrawIndirectCount is the maximum draw count that is supported for indirect draw calls. See multiDrawIndirect.
maxSamplerLodBias is the maximum absolute sampler LOD bias. The sum of the mipLodBias member of the VkSamplerCreateInfo structure and the Bias operand of image sampling operations in shader modules (or 0 if no Bias operand is provided to an image sampling operation) are clamped to the range [-maxSamplerLodBias,+maxSamplerLodBias]. See [samplers-mipLodBias].
maxSamplerAnisotropy is the maximum degree of sampler anisotropy. The maximum degree of anisotropic filtering used for an image sampling operation is the minimum of the maxAnisotropy member of the VkSamplerCreateInfo structure and this limit. See [samplers-maxAnisotropy].
maxViewports is the maximum number of active viewports. The viewportCount member of the VkPipelineViewportStateCreateInfo structure that is provided at pipeline creation must be less than or equal to this limit.
maxViewportDimensions[2] are the maximum viewport dimensions in the X (width) and Y (height) dimensions, respectively. The maximum viewport dimensions must be greater than or equal to the largest image which can be created and used as a framebuffer attachment. See Controlling the Viewport.

viewportBoundsRange[2] is the [minimum, maximum] range that the corners of a viewport must be contained in. This range must be at least [-2 × size, 2 × size - 1], where size = max(maxViewportDimensions[0], maxViewportDimensions[1]). See Controlling the Viewport.

Note

The intent of the viewportBoundsRange limit is to allow a maximum sized viewport to be arbitrarily shifted relative to the output target as long as at least some portion intersects. This would give a bounds limit of [-size + 1, 2 × size - 1] which would allow all possible non-empty-set intersections of the output target and the viewport. Since these numbers are typically powers of two, picking the signed number range using the smallest possible number of bits ends up with the specified range.

viewportSubPixelBits is the number of bits of subpixel precision for viewport bounds. The subpixel precision that floating-point viewport bounds are interpreted at is given by this limit.
minMemoryMapAlignment is the minimum required alignment, in bytes, of host visible memory allocations within the host address space. When mapping a memory allocation with vkMapMemory, subtracting offset bytes from the returned pointer will always produce an integer multiple of this limit. See Host Access to Device Memory Objects.
minTexelBufferOffsetAlignment is the minimum required alignment, in bytes, for the offset member of the VkBufferViewCreateInfo structure for texel buffers. If texelBufferAlignment is enabled, this limit is equivalent to the maximum of the uniformTexelBufferOffsetAlignmentBytes and storageTexelBufferOffsetAlignmentBytes members of VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT, but smaller alignment is optionally: allowed by storageTexelBufferOffsetSingleTexelAlignment and uniformTexelBufferOffsetSingleTexelAlignment. If texelBufferAlignment is not enabled, VkBufferViewCreateInfo::offset must be a multiple of this value.
minUniformBufferOffsetAlignment is the minimum required alignment, in bytes, for the offset member of the VkDescriptorBufferInfo structure for uniform buffers. When a descriptor of type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC is updated, the offset must be an integer multiple of this limit. Similarly, dynamic offsets for uniform buffers must be multiples of this limit.
minStorageBufferOffsetAlignment is the minimum required alignment, in bytes, for the offset member of the VkDescriptorBufferInfo structure for storage buffers. When a descriptor of type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC is updated, the offset must be an integer multiple of this limit. Similarly, dynamic offsets for storage buffers must be multiples of this limit.
minTexelOffset is the minimum offset value for the ConstOffset image operand of any of the OpImageSample* or OpImageFetch* image instructions.
maxTexelOffset is the maximum offset value for the ConstOffset image operand of any of the OpImageSample* or OpImageFetch* image instructions.
minTexelGatherOffset is the minimum offset value for the Offset, ConstOffset, or ConstOffsets image operands of any of the OpImage*Gather image instructions.
maxTexelGatherOffset is the maximum offset value for the Offset, ConstOffset, or ConstOffsets image operands of any of the OpImage*Gather image instructions.
minInterpolationOffset is the minimum negative offset value for the offset operand of the InterpolateAtOffset extended instruction.
maxInterpolationOffset is the maximum positive offset value for the offset operand of the InterpolateAtOffset extended instruction.
subPixelInterpolationOffsetBits is the number of subpixel fractional bits that the x and y offsets to the InterpolateAtOffset extended instruction may be rounded to as fixed-point values.
maxFramebufferWidth is the maximum width for a framebuffer. The width member of the VkFramebufferCreateInfo structure must be less than or equal to this limit.
maxFramebufferHeight is the maximum height for a framebuffer. The height member of the VkFramebufferCreateInfo structure must be less than or equal to this limit.
maxFramebufferLayers is the maximum layer count for a layered framebuffer. The layers member of the VkFramebufferCreateInfo structure must be less than or equal to this limit.
framebufferColorSampleCounts is a bitmask¹ of VkSampleCountFlagBits indicating the color sample counts that are supported for all framebuffer color attachments with floating- or fixed-point formats. There is no limit that specifies the color sample counts that are supported for all color attachments with integer formats.
framebufferDepthSampleCounts is a bitmask¹ of VkSampleCountFlagBits indicating the supported depth sample counts for all framebuffer depth/stencil attachments, when the format includes a depth component.
framebufferStencilSampleCounts is a bitmask¹ of VkSampleCountFlagBits indicating the supported stencil sample counts for all framebuffer depth/stencil attachments, when the format includes a stencil component.
framebufferNoAttachmentsSampleCounts is a bitmask¹ of VkSampleCountFlagBits indicating the supported sample counts for a framebuffer with no attachments.
maxColorAttachments is the maximum number of color attachments that can be used by a subpass in a render pass. The colorAttachmentCount member of the VkSubpassDescription structure must be less than or equal to this limit.
sampledImageColorSampleCounts is a bitmask¹ of VkSampleCountFlagBits indicating the sample counts supported for all 2D images created with VK_IMAGE_TILING_OPTIMAL, usage containing VK_IMAGE_USAGE_SAMPLED_BIT, and a non-integer color format.
sampledImageIntegerSampleCounts is a bitmask¹ of VkSampleCountFlagBits indicating the sample counts supported for all 2D images created with VK_IMAGE_TILING_OPTIMAL, usage containing VK_IMAGE_USAGE_SAMPLED_BIT, and an integer color format.
sampledImageDepthSampleCounts is a bitmask¹ of VkSampleCountFlagBits indicating the sample counts supported for all 2D images created with VK_IMAGE_TILING_OPTIMAL, usage containing VK_IMAGE_USAGE_SAMPLED_BIT, and a depth format.
sampledImageStencilSampleCounts is a bitmask¹ of VkSampleCountFlagBits indicating the sample supported for all 2D images created with VK_IMAGE_TILING_OPTIMAL, usage containing VK_IMAGE_USAGE_SAMPLED_BIT, and a stencil format.
storageImageSampleCounts is a bitmask¹ of VkSampleCountFlagBits indicating the sample counts supported for all 2D images created with VK_IMAGE_TILING_OPTIMAL, and usage containing VK_IMAGE_USAGE_STORAGE_BIT.
maxSampleMaskWords is the maximum number of array elements of a variable decorated with the SampleMask built-in decoration.
timestampComputeAndGraphics specifies support for timestamps on all graphics and compute queues. If this limit is set to VK_TRUE, all queues that advertise the VK_QUEUE_GRAPHICS_BIT or VK_QUEUE_COMPUTE_BIT in the VkQueueFamilyProperties::queueFlags support VkQueueFamilyProperties::timestampValidBits of at least 36. See Timestamp Queries.
timestampPeriod is the number of nanoseconds required for a timestamp query to be incremented by 1. See Timestamp Queries.
maxClipDistances is the maximum number of clip distances that can be used in a single shader stage. The size of any array declared with the ClipDistance built-in decoration in a shader module must be less than or equal to this limit.
maxCullDistances is the maximum number of cull distances that can be used in a single shader stage. The size of any array declared with the CullDistance built-in decoration in a shader module must be less than or equal to this limit.
maxCombinedClipAndCullDistances is the maximum combined number of clip and cull distances that can be used in a single shader stage. The sum of the sizes of any pair of arrays declared with the ClipDistance and CullDistance built-in decoration used by a single shader stage in a shader module must be less than or equal to this limit.
discreteQueuePriorities is the number of discrete priorities that can be assigned to a queue based on the value of each member of VkDeviceQueueCreateInfo::pQueuePriorities. This must be at least 2, and levels must be spread evenly over the range, with at least one level at 1.0, and another at 0.0. See Queue Priority.
pointSizeRange[2] is the range [minimum,maximum] of supported sizes for points. Values written to variables decorated with the PointSize built-in decoration are clamped to this range.
lineWidthRange[2] is the range [minimum,maximum] of supported widths for lines. Values specified by the lineWidth member of the VkPipelineRasterizationStateCreateInfo or the lineWidth parameter to vkCmdSetLineWidth are clamped to this range.
pointSizeGranularity is the granularity of supported point sizes. Not all point sizes in the range defined by pointSizeRange are supported. This limit specifies the granularity (or increment) between successive supported point sizes.
lineWidthGranularity is the granularity of supported line widths. Not all line widths in the range defined by lineWidthRange are supported. This limit specifies the granularity (or increment) between successive supported line widths.
strictLines specifies whether lines are rasterized according to the preferred method of rasterization. If set to VK_FALSE, lines may be rasterized under a relaxed set of rules. If set to VK_TRUE, lines are rasterized as per the strict definition. See Basic Line Segment Rasterization.
standardSampleLocations specifies whether rasterization uses the standard sample locations as documented in Multisampling. If set to VK_TRUE, the implementation uses the documented sample locations. If set to VK_FALSE, the implementation may use different sample locations.
optimalBufferCopyOffsetAlignment is the optimal buffer offset alignment in bytes for vkCmdCopyBufferToImage and vkCmdCopyImageToBuffer. The per texel alignment requirements are enforced, but applications should use the optimal alignment for optimal performance and power use.
optimalBufferCopyRowPitchAlignment is the optimal buffer row pitch alignment in bytes for vkCmdCopyBufferToImage and vkCmdCopyImageToBuffer. Row pitch is the number of bytes between texels with the same X coordinate in adjacent rows (Y coordinates differ by one). The per texel alignment requirements are enforced, but applications should use the optimal alignment for optimal performance and power use.
nonCoherentAtomSize is the size and alignment in bytes that bounds concurrent access to host-mapped device memory.

1: For all bitmasks of VkSampleCountFlagBits, the sample count limits defined above represent the minimum supported sample counts for each image type. Individual images may support additional sample counts, which are queried using vkGetPhysicalDeviceImageFormatProperties as described in Supported Sample Counts.

Bits which may be set in the sample count limits returned by VkPhysicalDeviceLimits, as well as in other queries and structures representing image sample counts, are:

typedef enum VkSampleCountFlagBits {
    VK_SAMPLE_COUNT_1_BIT = 0x00000001,
    VK_SAMPLE_COUNT_2_BIT = 0x00000002,
    VK_SAMPLE_COUNT_4_BIT = 0x00000004,
    VK_SAMPLE_COUNT_8_BIT = 0x00000008,
    VK_SAMPLE_COUNT_16_BIT = 0x00000010,
    VK_SAMPLE_COUNT_32_BIT = 0x00000020,
    VK_SAMPLE_COUNT_64_BIT = 0x00000040,
    VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkSampleCountFlagBits;

VK_SAMPLE_COUNT_1_BIT specifies an image with one sample per pixel.
VK_SAMPLE_COUNT_2_BIT specifies an image with 2 samples per pixel.
VK_SAMPLE_COUNT_4_BIT specifies an image with 4 samples per pixel.
VK_SAMPLE_COUNT_8_BIT specifies an image with 8 samples per pixel.
VK_SAMPLE_COUNT_16_BIT specifies an image with 16 samples per pixel.
VK_SAMPLE_COUNT_32_BIT specifies an image with 32 samples per pixel.
VK_SAMPLE_COUNT_64_BIT specifies an image with 64 samples per pixel.

typedef VkFlags VkSampleCountFlags;

VkSampleCountFlags is a bitmask type for setting a mask of zero or more VkSampleCountFlagBits.

The VkPhysicalDevicePushDescriptorPropertiesKHR structure is defined as:

typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           maxPushDescriptors;
} VkPhysicalDevicePushDescriptorPropertiesKHR;

The members of the VkPhysicalDevicePushDescriptorPropertiesKHR structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
maxPushDescriptors is the maximum number of descriptors that can be used in a descriptor set created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR set.

If the VkPhysicalDevicePushDescriptorPropertiesKHR structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDevicePushDescriptorPropertiesKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR

The VkPhysicalDeviceMultiviewProperties structure is defined as:

typedef struct VkPhysicalDeviceMultiviewProperties {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           maxMultiviewViewCount;
    uint32_t           maxMultiviewInstanceIndex;
} VkPhysicalDeviceMultiviewProperties;

or the equivalent

typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR;

The members of the VkPhysicalDeviceMultiviewProperties structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.

maxMultiviewViewCount is one greater than the maximum view index that can be used in a subpass.
maxMultiviewInstanceIndex is the maximum valid value of instance index allowed to be generated by a drawing command recorded within a subpass of a multiview render pass instance.

If the VkPhysicalDeviceMultiviewProperties structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceMultiviewProperties-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES

The VkPhysicalDeviceFloatControlsProperties structure is defined as:

typedef struct VkPhysicalDeviceFloatControlsProperties {
    VkStructureType                      sType;
    void*                                pNext;
    VkShaderFloatControlsIndependence    denormBehaviorIndependence;
    VkShaderFloatControlsIndependence    roundingModeIndependence;
    VkBool32                             shaderSignedZeroInfNanPreserveFloat16;
    VkBool32                             shaderSignedZeroInfNanPreserveFloat32;
    VkBool32                             shaderSignedZeroInfNanPreserveFloat64;
    VkBool32                             shaderDenormPreserveFloat16;
    VkBool32                             shaderDenormPreserveFloat32;
    VkBool32                             shaderDenormPreserveFloat64;
    VkBool32                             shaderDenormFlushToZeroFloat16;
    VkBool32                             shaderDenormFlushToZeroFloat32;
    VkBool32                             shaderDenormFlushToZeroFloat64;
    VkBool32                             shaderRoundingModeRTEFloat16;
    VkBool32                             shaderRoundingModeRTEFloat32;
    VkBool32                             shaderRoundingModeRTEFloat64;
    VkBool32                             shaderRoundingModeRTZFloat16;
    VkBool32                             shaderRoundingModeRTZFloat32;
    VkBool32                             shaderRoundingModeRTZFloat64;
} VkPhysicalDeviceFloatControlsProperties;

or the equivalent

typedef VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatControlsPropertiesKHR;

The members of the VkPhysicalDeviceFloatControlsProperties structure describe the following implementation-dependent limits:

denormBehaviorIndependence is a VkShaderFloatControlsIndependence value indicating whether, and how, denorm behavior can be set independently for different bit widths.
roundingModeIndependence is a VkShaderFloatControlsIndependence value indicating whether, and how, rounding modes can be set independently for different bit widths.
shaderSignedZeroInfNanPreserveFloat16 is a boolean value indicating whether sign of a zero, Nans and \(\pm\infty\) can be preserved in 16-bit floating-point computations. It also indicates whether the SignedZeroInfNanPreserve execution mode can be used for 16-bit floating-point types.
shaderSignedZeroInfNanPreserveFloat32 is a boolean value indicating whether sign of a zero, Nans and \(\pm\infty\) can be preserved in 32-bit floating-point computations. It also indicates whether the SignedZeroInfNanPreserve execution mode can be used for 32-bit floating-point types.
shaderSignedZeroInfNanPreserveFloat64 is a boolean value indicating whether sign of a zero, Nans and \(\pm\infty\) can be preserved in 64-bit floating-point computations. It also indicates whether the SignedZeroInfNanPreserve execution mode can be used for 64-bit floating-point types.
shaderDenormPreserveFloat16 is a boolean value indicating whether denormals can be preserved in 16-bit floating-point computations. It also indicates whether the DenormPreserve execution mode can be used for 16-bit floating-point types.
shaderDenormPreserveFloat32 is a boolean value indicating whether denormals can be preserved in 32-bit floating-point computations. It also indicates whether the DenormPreserve execution mode can be used for 32-bit floating-point types.
shaderDenormPreserveFloat64 is a boolean value indicating whether denormals can be preserved in 64-bit floating-point computations. It also indicates whether the DenormPreserve execution mode can be used for 64-bit floating-point types.
shaderDenormFlushToZeroFloat16 is a boolean value indicating whether denormals can be flushed to zero in 16-bit floating-point computations. It also indicates whether the DenormFlushToZero execution mode can be used for 16-bit floating-point types.
shaderDenormFlushToZeroFloat32 is a boolean value indicating whether denormals can be flushed to zero in 32-bit floating-point computations. It also indicates whether the DenormFlushToZero execution mode can be used for 32-bit floating-point types.
shaderDenormFlushToZeroFloat64 is a boolean value indicating whether denormals can be flushed to zero in 64-bit floating-point computations. It also indicates whether the DenormFlushToZero execution mode can be used for 64-bit floating-point types.
shaderRoundingModeRTEFloat16 is a boolean value indicating whether an implementation supports the round-to-nearest-even rounding mode for 16-bit floating-point arithmetic and conversion instructions. It also indicates whether the RoundingModeRTE execution mode can be used for 16-bit floating-point types.
shaderRoundingModeRTEFloat32 is a boolean value indicating whether an implementation supports the round-to-nearest-even rounding mode for 32-bit floating-point arithmetic and conversion instructions. It also indicates whether the RoundingModeRTE execution mode can be used for 32-bit floating-point types.
shaderRoundingModeRTEFloat64 is a boolean value indicating whether an implementation supports the round-to-nearest-even rounding mode for 64-bit floating-point arithmetic and conversion instructions. It also indicates whether the RoundingModeRTE execution mode can be used for 64-bit floating-point types.
shaderRoundingModeRTZFloat16 is a boolean value indicating whether an implementation supports the round-towards-zero rounding mode for 16-bit floating-point arithmetic and conversion instructions. It also indicates whether the RoundingModeRTZ execution mode can be used for 16-bit floating-point types.
shaderRoundingModeRTZFloat32 is a boolean value indicating whether an implementation supports the round-towards-zero rounding mode for 32-bit floating-point arithmetic and conversion instructions. It also indicates whether the RoundingModeRTZ execution mode can be used for 32-bit floating-point types.
shaderRoundingModeRTZFloat64 is a boolean value indicating whether an implementation supports the round-towards-zero rounding mode for 64-bit floating-point arithmetic and conversion instructions. It also indicates whether the RoundingModeRTZ execution mode can be used for 64-bit floating-point types.

editing-note

Implementations may not be able to control behavior of denorms for floating-point atomics. This needs to be taken into account when such atomics will be added to Vulkan.

If the VkPhysicalDeviceFloatControlsProperties structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceFloatControlsProperties-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES

Values which may be returned in the denormBehaviorIndependence and roundingModeIndependence fields of VkPhysicalDeviceFloatControlsProperties are:

typedef enum VkShaderFloatControlsIndependence {
    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0,
    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1,
    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2,
    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY,
    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL,
    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE,
    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF
} VkShaderFloatControlsIndependence;

VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY specifies that shader float controls for 32-bit floating point can be set independently; other bit widths must be set identically to each other.
VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL specifies that shader float controls for all bit widths can be set independently.
VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE specifies that shader float controls for all bit widths must be set identically.

The VkPhysicalDeviceDiscardRectanglePropertiesEXT structure is defined as:

typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           maxDiscardRectangles;
} VkPhysicalDeviceDiscardRectanglePropertiesEXT;

The members of the VkPhysicalDeviceDiscardRectanglePropertiesEXT structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
maxDiscardRectangles is the maximum number of active discard rectangles that can be specified.

If the VkPhysicalDeviceDiscardRectanglePropertiesEXT structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceDiscardRectanglePropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT

The VkPhysicalDeviceSampleLocationsPropertiesEXT structure is defined as:

typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT {
    VkStructureType       sType;
    void*                 pNext;
    VkSampleCountFlags    sampleLocationSampleCounts;
    VkExtent2D            maxSampleLocationGridSize;
    float                 sampleLocationCoordinateRange[2];
    uint32_t              sampleLocationSubPixelBits;
    VkBool32              variableSampleLocations;
} VkPhysicalDeviceSampleLocationsPropertiesEXT;

The members of the VkPhysicalDeviceSampleLocationsPropertiesEXT structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
sampleLocationSampleCounts is a bitmask of VkSampleCountFlagBits indicating the sample counts supporting custom sample locations.
maxSampleLocationGridSize is the maximum size of the pixel grid in which sample locations can vary that is supported for all sample counts in sampleLocationSampleCounts.
sampleLocationCoordinateRange[2] is the range of supported sample location coordinates.
sampleLocationSubPixelBits is the number of bits of subpixel precision for sample locations.
variableSampleLocations specifies whether the sample locations used by all pipelines that will be bound to a command buffer during a subpass must match. If set to VK_TRUE, the implementation supports variable sample locations in a subpass. If set to VK_FALSE, then the sample locations must stay constant in each subpass.

If the VkPhysicalDeviceSampleLocationsPropertiesEXT structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceSampleLocationsPropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT

The VkPhysicalDeviceExternalMemoryHostPropertiesEXT structure is defined as:

typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkDeviceSize       minImportedHostPointerAlignment;
} VkPhysicalDeviceExternalMemoryHostPropertiesEXT;

The members of the VkPhysicalDeviceExternalMemoryHostPropertiesEXT structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
minImportedHostPointerAlignment is the minimum required alignment, in bytes, for the base address and size of host pointers that can be imported to a Vulkan memory object.

If the VkPhysicalDeviceExternalMemoryHostPropertiesEXT structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceExternalMemoryHostPropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT

The VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX structure is defined as:

typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           perViewPositionAllComponents;
} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;

The members of the VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
perViewPositionAllComponents is VK_TRUE if the implementation supports per-view position values that differ in components other than the X component.

If the VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX

The VkPhysicalDevicePointClippingProperties structure is defined as:

typedef struct VkPhysicalDevicePointClippingProperties {
    VkStructureType            sType;
    void*                      pNext;
    VkPointClippingBehavior    pointClippingBehavior;
} VkPhysicalDevicePointClippingProperties;

or the equivalent

typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR;

The members of the VkPhysicalDevicePointClippingProperties structure describe the following implementation-dependent limit:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.

pointClippingBehavior is a VkPointClippingBehavior value specifying the point clipping behavior supported by the implementation.

If the VkPhysicalDevicePointClippingProperties structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDevicePointClippingProperties-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES

The VkPhysicalDeviceSubgroupProperties structure is defined as:

typedef struct VkPhysicalDeviceSubgroupProperties {
    VkStructureType           sType;
    void*                     pNext;
    uint32_t                  subgroupSize;
    VkShaderStageFlags        supportedStages;
    VkSubgroupFeatureFlags    supportedOperations;
    VkBool32                  quadOperationsInAllStages;
} VkPhysicalDeviceSubgroupProperties;

The members of the VkPhysicalDeviceSubgroupProperties structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.

subgroupSize is the default number of invocations in each subgroup. subgroupSize is at least 1 if any of the physical device’s queues support VK_QUEUE_GRAPHICS_BIT or VK_QUEUE_COMPUTE_BIT. subgroupSize is a power-of-two.
supportedStages is a bitfield of VkShaderStageFlagBits describing the shader stages that group operations with subgroup scope are supported in. supportedStages will have the VK_SHADER_STAGE_COMPUTE_BIT bit set if any of the physical device’s queues support VK_QUEUE_COMPUTE_BIT.
supportedOperations is a bitmask of VkSubgroupFeatureFlagBits specifying the sets of group operations with subgroup scope supported on this device. supportedOperations will have the VK_SUBGROUP_FEATURE_BASIC_BIT bit set if any of the physical device’s queues support VK_QUEUE_GRAPHICS_BIT or VK_QUEUE_COMPUTE_BIT.
quadOperationsInAllStages is a boolean specifying whether quad group operations are available in all stages, or are restricted to fragment and compute stages.

If the VkPhysicalDeviceSubgroupProperties structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

If supportedOperations includes VK_SUBGROUP_FEATURE_QUAD_BIT, subgroupSize must be greater than or equal to 4.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceSubgroupProperties-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES

Bits which can be set in VkPhysicalDeviceSubgroupProperties::supportedOperations and VkPhysicalDeviceVulkan11Properties::subgroupSupportedOperations to specify supported group operations with subgroup scope are:

typedef enum VkSubgroupFeatureFlagBits {
    VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001,
    VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002,
    VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004,
    VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008,
    VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010,
    VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020,
    VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040,
    VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080,
    VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100,
    VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkSubgroupFeatureFlagBits;

VK_SUBGROUP_FEATURE_BASIC_BIT specifies the device will accept SPIR-V shader modules containing the GroupNonUniform capability.
VK_SUBGROUP_FEATURE_VOTE_BIT specifies the device will accept SPIR-V shader modules containing the GroupNonUniformVote capability.
VK_SUBGROUP_FEATURE_ARITHMETIC_BIT specifies the device will accept SPIR-V shader modules containing the GroupNonUniformArithmetic capability.
VK_SUBGROUP_FEATURE_BALLOT_BIT specifies the device will accept SPIR-V shader modules containing the GroupNonUniformBallot capability.
VK_SUBGROUP_FEATURE_SHUFFLE_BIT specifies the device will accept SPIR-V shader modules containing the GroupNonUniformShuffle capability.
VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT specifies the device will accept SPIR-V shader modules containing the GroupNonUniformShuffleRelative capability.
VK_SUBGROUP_FEATURE_CLUSTERED_BIT specifies the device will accept SPIR-V shader modules containing the GroupNonUniformClustered capability.
VK_SUBGROUP_FEATURE_QUAD_BIT specifies the device will accept SPIR-V shader modules containing the GroupNonUniformQuad capability.
VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV specifies the device will accept SPIR-V shader modules containing the GroupNonUniformPartitionedNV capability.

typedef VkFlags VkSubgroupFeatureFlags;

VkSubgroupFeatureFlags is a bitmask type for setting a mask of zero or more VkSubgroupFeatureFlagBits.

The VkPhysicalDeviceSubgroupSizeControlPropertiesEXT structure is defined as:

typedef struct VkPhysicalDeviceSubgroupSizeControlPropertiesEXT {
    VkStructureType       sType;
    void*                 pNext;
    uint32_t              minSubgroupSize;
    uint32_t              maxSubgroupSize;
    uint32_t              maxComputeWorkgroupSubgroups;
    VkShaderStageFlags    requiredSubgroupSizeStages;
} VkPhysicalDeviceSubgroupSizeControlPropertiesEXT;

The members of the VkPhysicalDeviceSubgroupSizeControlPropertiesEXT structure describe the following properties:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
minSubgroupSize is the minimum subgroup size supported by this device. minSubgroupSize is at least one if any of the physical device’s queues support VK_QUEUE_GRAPHICS_BIT or VK_QUEUE_COMPUTE_BIT. minSubgroupSize is a power-of-two. minSubgroupSize is less than or equal to maxSubgroupSize. minSubgroupSize is less than or equal to subgroupSize.
maxSubgroupSize is the maximum subgroup size supported by this device. maxSubgroupSize is at least one if any of the physical device’s queues support VK_QUEUE_GRAPHICS_BIT or VK_QUEUE_COMPUTE_BIT. maxSubgroupSize is a power-of-two. maxSubgroupSize is greater than or equal to minSubgroupSize. maxSubgroupSize is greater than or equal to subgroupSize.
maxComputeWorkgroupSubgroups is the maximum number of subgroups supported by the implementation within a workgroup.
requiredSubgroupSizeStages is a bitfield of what shader stages support having a required subgroup size specified.

If the VkPhysicalDeviceSubgroupSizeControlPropertiesEXT structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

If VkPhysicalDeviceSubgroupProperties::supportedOperations includes VK_SUBGROUP_FEATURE_QUAD_BIT, minSubgroupSize must be greater than or equal to 4.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceSubgroupSizeControlPropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT

The VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT structure is defined as:

typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           advancedBlendMaxColorAttachments;
    VkBool32           advancedBlendIndependentBlend;
    VkBool32           advancedBlendNonPremultipliedSrcColor;
    VkBool32           advancedBlendNonPremultipliedDstColor;
    VkBool32           advancedBlendCorrelatedOverlap;
    VkBool32           advancedBlendAllOperations;
} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT;

The members of the VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
advancedBlendMaxColorAttachments is one greater than the highest color attachment index that can be used in a subpass, for a pipeline that uses an advanced blend operation.
advancedBlendIndependentBlend specifies whether advanced blend operations can vary per-attachment.
advancedBlendNonPremultipliedSrcColor specifies whether the source color can be treated as non-premultiplied. If this is VK_FALSE, then VkPipelineColorBlendAdvancedStateCreateInfoEXT::srcPremultiplied must be VK_TRUE.
advancedBlendNonPremultipliedDstColor specifies whether the destination color can be treated as non-premultiplied. If this is VK_FALSE, then VkPipelineColorBlendAdvancedStateCreateInfoEXT::dstPremultiplied must be VK_TRUE.
advancedBlendCorrelatedOverlap specifies whether the overlap mode can be treated as correlated. If this is VK_FALSE, then VkPipelineColorBlendAdvancedStateCreateInfoEXT::blendOverlap must be VK_BLEND_OVERLAP_UNCORRELATED_EXT.
advancedBlendAllOperations specifies whether all advanced blend operation enums are supported. See the valid usage of VkPipelineColorBlendAttachmentState.

If the VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT

The VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT structure is defined as:

typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           maxVertexAttribDivisor;
} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT;

The members of the VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
maxVertexAttribDivisor is the maximum value of the number of instances that will repeat the value of vertex attribute data when instanced rendering is enabled.

If the VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT

The VkPhysicalDeviceSamplerFilterMinmaxProperties structure is defined as:

typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           filterMinmaxSingleComponentFormats;
    VkBool32           filterMinmaxImageComponentMapping;
} VkPhysicalDeviceSamplerFilterMinmaxProperties;

or the equivalent

typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT;

The members of the VkPhysicalDeviceSamplerFilterMinmaxProperties structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.

filterMinmaxSingleComponentFormats is a boolean value indicating whether a minimum set of required formats support min/max filtering.
filterMinmaxImageComponentMapping is a boolean value indicating whether the implementation supports non-identity component mapping of the image when doing min/max filtering.

If the VkPhysicalDeviceSamplerFilterMinmaxProperties structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

If filterMinmaxSingleComponentFormats is VK_TRUE, the following formats must support the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT feature with VK_IMAGE_TILING_OPTIMAL, if they support VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT.

VK_FORMAT_R8_UNORM
VK_FORMAT_R8_SNORM
VK_FORMAT_R16_UNORM
VK_FORMAT_R16_SNORM
VK_FORMAT_R16_SFLOAT
VK_FORMAT_R32_SFLOAT
VK_FORMAT_D16_UNORM
VK_FORMAT_X8_D24_UNORM_PACK32
VK_FORMAT_D32_SFLOAT
VK_FORMAT_D16_UNORM_S8_UINT
VK_FORMAT_D24_UNORM_S8_UINT
VK_FORMAT_D32_SFLOAT_S8_UINT

If the format is a depth/stencil format, this bit only specifies that the depth aspect (not the stencil aspect) of an image of this format supports min/max filtering, and that min/max filtering of the depth aspect is supported when depth compare is disabled in the sampler.

If filterMinmaxImageComponentMapping is VK_FALSE the component mapping of the image view used with min/max filtering must have been created with the r component set to VK_COMPONENT_SWIZZLE_IDENTITY. Only the r component of the sampled image value is defined and the other component values are undefined. If filterMinmaxImageComponentMapping is VK_TRUE this restriction does not apply and image component mapping works as normal.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceSamplerFilterMinmaxProperties-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES

The VkPhysicalDeviceProtectedMemoryProperties structure is defined as:

typedef struct VkPhysicalDeviceProtectedMemoryProperties {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           protectedNoFault;
} VkPhysicalDeviceProtectedMemoryProperties;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.

protectedNoFault specifies the behavior of the implementation when protected memory access rules are broken. If protectedNoFault is VK_TRUE, breaking those rules will not result in process termination or device loss.

If the VkPhysicalDeviceProtectedMemoryProperties structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with a value indicating the implementation-dependent behavior.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceProtectedMemoryProperties-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES

The VkPhysicalDeviceMaintenance3Properties structure is defined as:

typedef struct VkPhysicalDeviceMaintenance3Properties {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           maxPerSetDescriptors;
    VkDeviceSize       maxMemoryAllocationSize;
} VkPhysicalDeviceMaintenance3Properties;

or the equivalent

typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR;

The members of the VkPhysicalDeviceMaintenance3Properties structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.

maxPerSetDescriptors is a maximum number of descriptors (summed over all descriptor types) in a single descriptor set that is guaranteed to satisfy any implementation-dependent constraints on the size of a descriptor set itself. Applications can query whether a descriptor set that goes beyond this limit is supported using vkGetDescriptorSetLayoutSupport.
maxMemoryAllocationSize is the maximum size of a memory allocation that can be created, even if there is more space available in the heap.

If the VkPhysicalDeviceMaintenance3Properties structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceMaintenance3Properties-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES

The VkPhysicalDeviceMeshShaderPropertiesNV structure is defined as:

typedef struct VkPhysicalDeviceMeshShaderPropertiesNV {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           maxDrawMeshTasksCount;
    uint32_t           maxTaskWorkGroupInvocations;
    uint32_t           maxTaskWorkGroupSize[3];
    uint32_t           maxTaskTotalMemorySize;
    uint32_t           maxTaskOutputCount;
    uint32_t           maxMeshWorkGroupInvocations;
    uint32_t           maxMeshWorkGroupSize[3];
    uint32_t           maxMeshTotalMemorySize;
    uint32_t           maxMeshOutputVertices;
    uint32_t           maxMeshOutputPrimitives;
    uint32_t           maxMeshMultiviewViewCount;
    uint32_t           meshOutputPerVertexGranularity;
    uint32_t           meshOutputPerPrimitiveGranularity;
} VkPhysicalDeviceMeshShaderPropertiesNV;

The members of the VkPhysicalDeviceMeshShaderPropertiesNV structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
maxDrawMeshTasksCount is the maximum number of local workgroups that can be launched by a single draw mesh tasks command. See Programmable Mesh Shading.
maxTaskWorkGroupInvocations is the maximum total number of task shader invocations in a single local workgroup. The product of the X, Y, and Z sizes, as specified by the LocalSize execution mode in shader modules or by the object decorated by the WorkgroupSize decoration, must be less than or equal to this limit.
maxTaskWorkGroupSize[3] is the maximum size of a local task workgroup. These three values represent the maximum local workgroup size in the X, Y, and Z dimensions, respectively. The x, y, and z sizes, as specified by the LocalSize execution mode or by the object decorated by the WorkgroupSize decoration in shader modules, must be less than or equal to the corresponding limit.
maxTaskTotalMemorySize is the maximum number of bytes that the task shader can use in total for shared and output memory combined.
maxTaskOutputCount is the maximum number of output tasks a single task shader workgroup can emit.
maxMeshWorkGroupInvocations is the maximum total number of mesh shader invocations in a single local workgroup. The product of the X, Y, and Z sizes, as specified by the LocalSize execution mode in shader modules or by the object decorated by the WorkgroupSize decoration, must be less than or equal to this limit.
maxMeshWorkGroupSize[3] is the maximum size of a local mesh workgroup. These three values represent the maximum local workgroup size in the X, Y, and Z dimensions, respectively. The x, y, and z sizes, as specified by the LocalSize execution mode or by the object decorated by the WorkgroupSize decoration in shader modules, must be less than or equal to the corresponding limit.
maxMeshTotalMemorySize is the maximum number of bytes that the mesh shader can use in total for shared and output memory combined.
maxMeshOutputVertices is the maximum number of vertices a mesh shader output can store.
maxMeshOutputPrimitives is the maximum number of primitives a mesh shader output can store.
maxMeshMultiviewViewCount is the maximum number of multi-view views a mesh shader can use.
meshOutputPerVertexGranularity is the granularity with which mesh vertex outputs are allocated. The value can be used to compute the memory size used by the mesh shader, which must be less than or equal to maxMeshTotalMemorySize.
meshOutputPerPrimitiveGranularity is the granularity with which mesh outputs qualified as per-primitive are allocated. The value can be used to compute the memory size used by the mesh shader, which must be less than or equal to maxMeshTotalMemorySize.

If the VkPhysicalDeviceMeshShaderPropertiesNV structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceMeshShaderPropertiesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV

The VkPhysicalDeviceDescriptorIndexingProperties structure is defined as:

typedef struct VkPhysicalDeviceDescriptorIndexingProperties {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           maxUpdateAfterBindDescriptorsInAllPools;
    VkBool32           shaderUniformBufferArrayNonUniformIndexingNative;
    VkBool32           shaderSampledImageArrayNonUniformIndexingNative;
    VkBool32           shaderStorageBufferArrayNonUniformIndexingNative;
    VkBool32           shaderStorageImageArrayNonUniformIndexingNative;
    VkBool32           shaderInputAttachmentArrayNonUniformIndexingNative;
    VkBool32           robustBufferAccessUpdateAfterBind;
    VkBool32           quadDivergentImplicitLod;
    uint32_t           maxPerStageDescriptorUpdateAfterBindSamplers;
    uint32_t           maxPerStageDescriptorUpdateAfterBindUniformBuffers;
    uint32_t           maxPerStageDescriptorUpdateAfterBindStorageBuffers;
    uint32_t           maxPerStageDescriptorUpdateAfterBindSampledImages;
    uint32_t           maxPerStageDescriptorUpdateAfterBindStorageImages;
    uint32_t           maxPerStageDescriptorUpdateAfterBindInputAttachments;
    uint32_t           maxPerStageUpdateAfterBindResources;
    uint32_t           maxDescriptorSetUpdateAfterBindSamplers;
    uint32_t           maxDescriptorSetUpdateAfterBindUniformBuffers;
    uint32_t           maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
    uint32_t           maxDescriptorSetUpdateAfterBindStorageBuffers;
    uint32_t           maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
    uint32_t           maxDescriptorSetUpdateAfterBindSampledImages;
    uint32_t           maxDescriptorSetUpdateAfterBindStorageImages;
    uint32_t           maxDescriptorSetUpdateAfterBindInputAttachments;
} VkPhysicalDeviceDescriptorIndexingProperties;

or the equivalent

typedef VkPhysicalDeviceDescriptorIndexingProperties VkPhysicalDeviceDescriptorIndexingPropertiesEXT;

The members of the VkPhysicalDeviceDescriptorIndexingProperties structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.

maxUpdateAfterBindDescriptorsInAllPools is the maximum number of descriptors (summed over all descriptor types) that can be created across all pools that are created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT bit set. Pool creation may fail when this limit is exceeded, or when the space this limit represents is unable to satisfy a pool creation due to fragmentation.
shaderUniformBufferArrayNonUniformIndexingNative is a boolean value indicating whether uniform buffer descriptors natively support nonuniform indexing. If this is VK_FALSE, then a single dynamic instance of an instruction that nonuniformly indexes an array of uniform buffers may execute multiple times in order to access all the descriptors.
shaderSampledImageArrayNonUniformIndexingNative is a boolean value indicating whether sampler and image descriptors natively support nonuniform indexing. If this is VK_FALSE, then a single dynamic instance of an instruction that nonuniformly indexes an array of samplers or images may execute multiple times in order to access all the descriptors.
shaderStorageBufferArrayNonUniformIndexingNative is a boolean value indicating whether storage buffer descriptors natively support nonuniform indexing. If this is VK_FALSE, then a single dynamic instance of an instruction that nonuniformly indexes an array of storage buffers may execute multiple times in order to access all the descriptors.
shaderStorageImageArrayNonUniformIndexingNative is a boolean value indicating whether storage image descriptors natively support nonuniform indexing. If this is VK_FALSE, then a single dynamic instance of an instruction that nonuniformly indexes an array of storage images may execute multiple times in order to access all the descriptors.
shaderInputAttachmentArrayNonUniformIndexingNative is a boolean value indicating whether input attachment descriptors natively support nonuniform indexing. If this is VK_FALSE, then a single dynamic instance of an instruction that nonuniformly indexes an array of input attachments may execute multiple times in order to access all the descriptors.
robustBufferAccessUpdateAfterBind is a boolean value indicating whether robustBufferAccess can be enabled in a device simultaneously with descriptorBindingUniformBufferUpdateAfterBind, descriptorBindingStorageBufferUpdateAfterBind, descriptorBindingUniformTexelBufferUpdateAfterBind, and/or descriptorBindingStorageTexelBufferUpdateAfterBind. If this is VK_FALSE, then either robustBufferAccess must be disabled or all of these update-after-bind features must be disabled.
quadDivergentImplicitLod is a boolean value indicating whether implicit level of detail calculations for image operations have well-defined results when the image and/or sampler objects used for the instruction are not uniform within a quad. See Derivative Image Operations.
maxPerStageDescriptorUpdateAfterBindSamplers is similar to maxPerStageDescriptorSamplers but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxPerStageDescriptorUpdateAfterBindUniformBuffers is similar to maxPerStageDescriptorUniformBuffers but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxPerStageDescriptorUpdateAfterBindStorageBuffers is similar to maxPerStageDescriptorStorageBuffers but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxPerStageDescriptorUpdateAfterBindSampledImages is similar to maxPerStageDescriptorSampledImages but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxPerStageDescriptorUpdateAfterBindStorageImages is similar to maxPerStageDescriptorStorageImages but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxPerStageDescriptorUpdateAfterBindInputAttachments is similar to maxPerStageDescriptorInputAttachments but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxPerStageUpdateAfterBindResources is similar to maxPerStageResources but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxDescriptorSetUpdateAfterBindSamplers is similar to maxDescriptorSetSamplers but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxDescriptorSetUpdateAfterBindUniformBuffers is similar to maxDescriptorSetUniformBuffers but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic is similar to maxDescriptorSetUniformBuffersDynamic but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxDescriptorSetUpdateAfterBindStorageBuffers is similar to maxDescriptorSetStorageBuffers but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic is similar to maxDescriptorSetStorageBuffersDynamic but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxDescriptorSetUpdateAfterBindSampledImages is similar to maxDescriptorSetSampledImages but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxDescriptorSetUpdateAfterBindStorageImages is similar to maxDescriptorSetStorageImages but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxDescriptorSetUpdateAfterBindInputAttachments is similar to maxDescriptorSetInputAttachments but counts descriptors from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.

If the VkPhysicalDeviceDescriptorIndexingProperties structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceDescriptorIndexingProperties-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES

The VkPhysicalDeviceInlineUniformBlockPropertiesEXT structure is defined as:

typedef struct VkPhysicalDeviceInlineUniformBlockPropertiesEXT {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           maxInlineUniformBlockSize;
    uint32_t           maxPerStageDescriptorInlineUniformBlocks;
    uint32_t           maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
    uint32_t           maxDescriptorSetInlineUniformBlocks;
    uint32_t           maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
} VkPhysicalDeviceInlineUniformBlockPropertiesEXT;

The members of the VkPhysicalDeviceInlineUniformBlockPropertiesEXT structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
maxInlineUniformBlockSize is the maximum size in bytes of an inline uniform block binding.
maxPerStageDescriptorInlineUniformBlock is the maximum number of inline uniform block bindings that can be accessible to a single shader stage in a pipeline layout. Descriptor bindings with a descriptor type of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT count against this limit. Only descriptor bindings in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit.
maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks is similar to maxPerStageDescriptorInlineUniformBlocks but counts descriptor bindings from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.
maxDescriptorSetInlineUniformBlocks is the maximum number of inline uniform block bindings that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptor bindings with a descriptor type of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT count against this limit. Only descriptor bindings in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit.
maxDescriptorSetUpdateAfterBindInlineUniformBlocks is similar to maxDescriptorSetInlineUniformBlocks but counts descriptor bindings from descriptor sets created with or without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set.

If the VkPhysicalDeviceInlineUniformBlockPropertiesEXT structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceInlineUniformBlockPropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT

The VkPhysicalDeviceConservativeRasterizationPropertiesEXT structure is defined as:

typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT {
    VkStructureType    sType;
    void*              pNext;
    float              primitiveOverestimationSize;
    float              maxExtraPrimitiveOverestimationSize;
    float              extraPrimitiveOverestimationSizeGranularity;
    VkBool32           primitiveUnderestimation;
    VkBool32           conservativePointAndLineRasterization;
    VkBool32           degenerateTrianglesRasterized;
    VkBool32           degenerateLinesRasterized;
    VkBool32           fullyCoveredFragmentShaderInputVariable;
    VkBool32           conservativeRasterizationPostDepthCoverage;
} VkPhysicalDeviceConservativeRasterizationPropertiesEXT;

The members of the VkPhysicalDeviceConservativeRasterizationPropertiesEXT structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
primitiveOverestimationSize is the size in pixels the generating primitive is increased at each of its edges during conservative rasterization overestimation mode. Even with a size of 0.0, conservative rasterization overestimation rules still apply and if any part of the pixel rectangle is covered by the generating primitive, fragments are generated for the entire pixel. However implementations may make the pixel coverage area even more conservative by increasing the size of the generating primitive.
maxExtraPrimitiveOverestimationSize is the maximum size in pixels of extra overestimation the implementation supports in the pipeline state. A value of 0.0 means the implementation does not support any additional overestimation of the generating primitive during conservative rasterization. A value above 0.0 allows the application to further increase the size of the generating primitive during conservative rasterization overestimation.
extraPrimitiveOverestimationSizeGranularity is the granularity of extra overestimation that can be specified in the pipeline state between 0.0 and maxExtraPrimitiveOverestimationSize inclusive. A value of 0.0 means the implementation can use the smallest representable non-zero value in the screen space pixel fixed-point grid.
primitiveUnderestimation is true if the implementation supports the VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT conservative rasterization mode in addition to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT. Otherwise the implementation only supports VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT.
conservativePointAndLineRasterization is true if the implementation supports conservative rasterization of point and line primitives as well as triangle primitives. Otherwise the implementation only supports triangle primitives.
degenerateTrianglesRasterized is false if the implementation culls primitives generated from triangles that become zero area after they are quantized to the fixed-point rasterization pixel grid. degenerateTrianglesRasterized is true if these primitives are not culled and the provoking vertex attributes and depth value are used for the fragments. The primitive area calculation is done on the primitive generated from the clipped triangle if applicable. Zero area primitives are backfacing and the application can enable backface culling if desired.
degenerateLinesRasterized is false if the implementation culls lines that become zero length after they are quantized to the fixed-point rasterization pixel grid. degenerateLinesRasterized is true if zero length lines are not culled and the provoking vertex attributes and depth value are used for the fragments.
fullyCoveredFragmentShaderInputVariable is true if the implementation supports the SPIR-V builtin fragment shader input variable FullyCoveredEXT which specifies that conservative rasterization is enabled and the fragment area is fully covered by the generating primitive.
conservativeRasterizationPostDepthCoverage is true if the implementation supports conservative rasterization with the PostDepthCoverage execution mode enabled. When supported the SampleMask built-in input variable will reflect the coverage after the early per-fragment depth and stencil tests are applied even when conservative rasterization is enabled. Otherwise PostDepthCoverage execution mode must not be used when conservative rasterization is enabled.

If the VkPhysicalDeviceConservativeRasterizationPropertiesEXT structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits and properties.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceConservativeRasterizationPropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT

The VkPhysicalDeviceFragmentDensityMapPropertiesEXT structure is defined as:

typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkExtent2D         minFragmentDensityTexelSize;
    VkExtent2D         maxFragmentDensityTexelSize;
    VkBool32           fragmentDensityInvocations;
} VkPhysicalDeviceFragmentDensityMapPropertiesEXT;

The members of the VkPhysicalDeviceFragmentDensityMapPropertiesEXT structure describe the following implementation-dependent limits:

minFragmentDensityTexelSize is the minimum fragment density texel size.
maxFragmentDensityTexelSize is the maximum fragment density texel size.
fragmentDensityInvocations specifies whether the implementation may invoke additional fragment shader invocations for each covered sample.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceFragmentDensityMapPropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT

If the VkPhysicalDeviceFragmentDensityMapPropertiesEXT structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits and properties.

The VkPhysicalDeviceShaderCorePropertiesAMD structure is defined as:

typedef struct VkPhysicalDeviceShaderCorePropertiesAMD {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           shaderEngineCount;
    uint32_t           shaderArraysPerEngineCount;
    uint32_t           computeUnitsPerShaderArray;
    uint32_t           simdPerComputeUnit;
    uint32_t           wavefrontsPerSimd;
    uint32_t           wavefrontSize;
    uint32_t           sgprsPerSimd;
    uint32_t           minSgprAllocation;
    uint32_t           maxSgprAllocation;
    uint32_t           sgprAllocationGranularity;
    uint32_t           vgprsPerSimd;
    uint32_t           minVgprAllocation;
    uint32_t           maxVgprAllocation;
    uint32_t           vgprAllocationGranularity;
} VkPhysicalDeviceShaderCorePropertiesAMD;

The members of the VkPhysicalDeviceShaderCorePropertiesAMD structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
shaderEngineCount is an unsigned integer value indicating the number of shader engines found inside the shader core of the physical device.
shaderArraysPerEngineCount is an unsigned integer value indicating the number of shader arrays inside a shader engine. Each shader array has its own scan converter, set of compute units, and a render back end (color and depth buffers). Shader arrays within a shader engine share shader processor input (wave launcher) and shader export (export buffer) units. Currently, a shader engine can have one or two shader arrays.
computeUnitsPerShaderArray is an unsigned integer value indicating the physical number of compute units within a shader array. The active number of compute units in a shader array may be lower. A compute unit houses a set of SIMDs along with a sequencer module and a local data store.
simdPerComputeUnit is an unsigned integer value indicating the number of SIMDs inside a compute unit. Each SIMD processes a single instruction at a time.
wavefrontSize is an unsigned integer value indicating the maximum size of a subgroup.
sgprsPerSimd is an unsigned integer value indicating the number of physical Scalar General Purpose Registers (SGPRs) per SIMD.
minSgprAllocation is an unsigned integer value indicating the minimum number of SGPRs allocated for a wave.
maxSgprAllocation is an unsigned integer value indicating the maximum number of SGPRs allocated for a wave.
sgprAllocationGranularity is an unsigned integer value indicating the granularity of SGPR allocation for a wave.
vgprsPerSimd is an unsigned integer value indicating the number of physical Vector General Purpose Registers (VGPRs) per SIMD.
minVgprAllocation is an unsigned integer value indicating the minimum number of VGPRs allocated for a wave.
maxVgprAllocation is an unsigned integer value indicating the maximum number of VGPRs allocated for a wave.
vgprAllocationGranularity is an unsigned integer value indicating the granularity of VGPR allocation for a wave.

If the VkPhysicalDeviceShaderCorePropertiesAMD structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceShaderCorePropertiesAMD-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD

The VkPhysicalDeviceShaderCoreProperties2AMD structure is defined as:

typedef struct VkPhysicalDeviceShaderCoreProperties2AMD {
    VkStructureType                   sType;
    void*                             pNext;
    VkShaderCorePropertiesFlagsAMD    shaderCoreFeatures;
    uint32_t                          activeComputeUnitCount;
} VkPhysicalDeviceShaderCoreProperties2AMD;

The members of the VkPhysicalDeviceShaderCoreProperties2AMD structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
shaderCoreFeatures is a bitmask of VkShaderCorePropertiesFlagBitsAMD indicating the set of features supported by the shader core.
activeComputeUnitCount is an unsigned integer value indicating the number of compute units that have been enabled.

If the VkPhysicalDeviceShaderCoreProperties2AMD structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceShaderCoreProperties2AMD-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD

Bits for this type may be defined by future extensions, or new versions of the VK_AMD_shader_core_properties2 extension. Possible values of the flags member of VkShaderCorePropertiesFlagsAMD are:

typedef enum VkShaderCorePropertiesFlagBitsAMD {
    VK_SHADER_CORE_PROPERTIES_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF
} VkShaderCorePropertiesFlagBitsAMD;

typedef VkFlags VkShaderCorePropertiesFlagsAMD;

VkShaderCorePropertiesFlagsAMD is a bitmask type for providing zero or more VkShaderCorePropertiesFlagBitsAMD.

The VkPhysicalDeviceDepthStencilResolveProperties structure is defined as:

typedef struct VkPhysicalDeviceDepthStencilResolveProperties {
    VkStructureType       sType;
    void*                 pNext;
    VkResolveModeFlags    supportedDepthResolveModes;
    VkResolveModeFlags    supportedStencilResolveModes;
    VkBool32              independentResolveNone;
    VkBool32              independentResolve;
} VkPhysicalDeviceDepthStencilResolveProperties;

or the equivalent

typedef VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDepthStencilResolvePropertiesKHR;

The members of the VkPhysicalDeviceDepthStencilResolveProperties structure describe the following implementation-dependent limits:

supportedDepthResolveModes is a bitmask of VkResolveModeFlagBits indicating the set of supported depth resolve modes. VK_RESOLVE_MODE_SAMPLE_ZERO_BIT must be included in the set but implementations may support additional modes.
supportedStencilResolveModes is a bitmask of VkResolveModeFlagBits indicating the set of supported stencil resolve modes. VK_RESOLVE_MODE_SAMPLE_ZERO_BIT must be included in the set but implementations may support additional modes. VK_RESOLVE_MODE_AVERAGE_BIT must not be included in the set.
independentResolveNone is VK_TRUE if the implementation supports setting the depth and stencil resolve modes to different values when one of those modes is VK_RESOLVE_MODE_NONE. Otherwise the implementation only supports setting both modes to the same value.
independentResolve is VK_TRUE if the implementation supports all combinations of the supported depth and stencil resolve modes, including setting either depth or stencil resolve mode to VK_RESOLVE_MODE_NONE. An implementation that supports independentResolve must also support independentResolveNone.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceDepthStencilResolveProperties-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES

The VkPhysicalDevicePerformanceQueryFeaturesKHR structure is defined as:

typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           performanceCounterQueryPools;
    VkBool32           performanceCounterMultipleQueryPools;
} VkPhysicalDevicePerformanceQueryFeaturesKHR;

The members of the VkPhysicalDevicePerformanceQueryFeaturesKHR structure describe the following implementation-dependent features:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
performanceCounterQueryPools is VK_TRUE if the physical device supports performance counter query pools.
performanceCounterMultipleQueryPools is VK_TRUE` if the physical device supports using multiple performance query pools in a primary command buffer and secondary command buffers executed within it.

Valid Usage (Implicit)

VUID-VkPhysicalDevicePerformanceQueryFeaturesKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR

To query supported performance counter query pool features, call vkGetPhysicalDeviceFeatures2 with a VkPhysicalDevicePerformanceQueryFeaturesKHR structure included in the pNext chain of its pFeatures parameter. The VkPhysicalDevicePerformanceQueryFeaturesKHR structure can also be included in the pNext chain of a VkDeviceCreateInfo structure, in which case it controls which additional features are enabled in the device.

The VkPhysicalDevicePerformanceQueryPropertiesKHR structure is defined as:

typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           allowCommandBufferQueryCopies;
} VkPhysicalDevicePerformanceQueryPropertiesKHR;

The members of the VkPhysicalDevicePerformanceQueryPropertiesKHR structure describe the following implementation-dependent properties:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
allowCommandBufferQueryCopies is VK_TRUE if the performance query pools are allowed to be used with vkCmdCopyQueryPoolResults.

Valid Usage (Implicit)

VUID-VkPhysicalDevicePerformanceQueryPropertiesKHR-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR

If the VkPhysicalDevicePerformanceQueryPropertiesKHR structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent properties.

The VkPhysicalDeviceShadingRateImagePropertiesNV structure is defined as:

typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV {
    VkStructureType    sType;
    void*              pNext;
    VkExtent2D         shadingRateTexelSize;
    uint32_t           shadingRatePaletteSize;
    uint32_t           shadingRateMaxCoarseSamples;
} VkPhysicalDeviceShadingRateImagePropertiesNV;

The members of the VkPhysicalDeviceShadingRateImagePropertiesNV structure describe the following implementation-dependent properties related to the shading rate image feature:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
shadingRateTexelSize indicates the width and height of the portion of the framebuffer corresponding to each texel in the shading rate image.
shadingRatePaletteSize indicates the maximum number of palette entries supported for the shading rate image.
shadingRateMaxCoarseSamples specifies the maximum number of coverage samples supported in a single fragment. If the product of the fragment size derived from the base shading rate and the number of coverage samples per pixel exceeds this limit, the final shading rate will be adjusted so that its product does not exceed the limit.

If the VkPhysicalDeviceShadingRateImagePropertiesNV structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceShadingRateImagePropertiesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV

The VkPhysicalDeviceTransformFeedbackPropertiesEXT structure is defined as:

typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           maxTransformFeedbackStreams;
    uint32_t           maxTransformFeedbackBuffers;
    VkDeviceSize       maxTransformFeedbackBufferSize;
    uint32_t           maxTransformFeedbackStreamDataSize;
    uint32_t           maxTransformFeedbackBufferDataSize;
    uint32_t           maxTransformFeedbackBufferDataStride;
    VkBool32           transformFeedbackQueries;
    VkBool32           transformFeedbackStreamsLinesTriangles;
    VkBool32           transformFeedbackRasterizationStreamSelect;
    VkBool32           transformFeedbackDraw;
} VkPhysicalDeviceTransformFeedbackPropertiesEXT;

The members of the VkPhysicalDeviceTransformFeedbackPropertiesEXT structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
maxTransformFeedbackStreams is the maximum number of vertex streams that can be output from geometry shaders declared with the GeometryStreams capability. If the implementation does not support VkPhysicalDeviceTransformFeedbackFeaturesEXT::geometryStreams then maxTransformFeedbackStreams must be set to 1.
maxTransformFeedbackBuffers is the maximum number of transform feedback buffers that can be bound for capturing shader outputs from the last vertex processing stage.
maxTransformFeedbackBufferSize is the maximum size that can be specified when binding a buffer for transform feedback in vkCmdBindTransformFeedbackBuffersEXT.
maxTransformFeedbackStreamDataSize is the maximum amount of data in bytes for each vertex that captured to one or more transform feedback buffers associated with a specific vertex stream.
maxTransformFeedbackBufferDataSize is the maximum amount of data in bytes for each vertex that can be captured to a specific transform feedback buffer.
maxTransformFeedbackBufferDataStride is the maximum stride between each capture of vertex data to the buffer.
transformFeedbackQueries is true if the implementation supports the VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT query type. transformFeedbackQueries is false if queries of this type cannot be created.
transformFeedbackStreamsLinesTriangles is true if the implementation supports the geometry shader OpExecutionMode of OutputLineStrip and OutputTriangleStrip in addition to OutputPoints when more than one vertex stream is output. If transformFeedbackStreamsLinesTriangles is false the implementation only supports an OpExecutionMode of OutputPoints when more than one vertex stream is output from the geometry shader.
transformFeedbackRasterizationStreamSelect is true if the implementation supports the GeometryStreams SPIR-V capability and the application can use VkPipelineRasterizationStateStreamCreateInfoEXT to modify which vertex stream output is used for rasterization. Otherwise vertex stream 0 must always be used for rasterization.
transformFeedbackDraw is true if the implementation supports the vkCmdDrawIndirectByteCountEXT function otherwise the function must not be called.

If the VkPhysicalDeviceTransformFeedbackPropertiesEXT structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits and properties.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceTransformFeedbackPropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT

The VkPhysicalDeviceRayTracingPropertiesNV structure is defined as:

typedef struct VkPhysicalDeviceRayTracingPropertiesNV {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           shaderGroupHandleSize;
    uint32_t           maxRecursionDepth;
    uint32_t           maxShaderGroupStride;
    uint32_t           shaderGroupBaseAlignment;
    uint64_t           maxGeometryCount;
    uint64_t           maxInstanceCount;
    uint64_t           maxTriangleCount;
    uint32_t           maxDescriptorSetAccelerationStructures;
} VkPhysicalDeviceRayTracingPropertiesNV;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
shaderGroupHandleSize size in bytes of the shader header.
maxRecursionDepth is the maximum number of levels of recursion allowed in a trace command.
maxShaderGroupStride is the maximum stride in bytes allowed between shader groups in the SBT.
shaderGroupBaseAlignment is the required alignment in bytes for the base of the SBTs.
maxGeometryCount is the maximum number of geometries in the bottom level acceleration structure.
maxInstanceCount is the maximum number of instances in the top level acceleration structure.
maxTriangleCount is the maximum number of triangles in all geometries in the bottom level acceleration structure.
maxDescriptorSetAccelerationStructures is the maximum number of acceleration structure descriptors that are allowed in a descriptor set.

If the VkPhysicalDeviceRayTracingPropertiesNV structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceRayTracingPropertiesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV

The VkPhysicalDeviceCooperativeMatrixPropertiesNV structure is defined as:

typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV {
    VkStructureType       sType;
    void*                 pNext;
    VkShaderStageFlags    cooperativeMatrixSupportedStages;
} VkPhysicalDeviceCooperativeMatrixPropertiesNV;

The members of the VkPhysicalDeviceCooperativeMatrixPropertiesNV structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
cooperativeMatrixSupportedStages is a bitfield of VkShaderStageFlagBits describing the shader stages that cooperative matrix instructions are supported in. cooperativeMatrixSupportedStages will have the VK_SHADER_STAGE_COMPUTE_BIT bit set if any of the physical device’s queues support VK_QUEUE_COMPUTE_BIT.

If the VkPhysicalDeviceCooperativeMatrixPropertiesNV structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceCooperativeMatrixPropertiesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV

The VkPhysicalDeviceShaderSMBuiltinsPropertiesNV structure is defined as:

typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           shaderSMCount;
    uint32_t           shaderWarpsPerSM;
} VkPhysicalDeviceShaderSMBuiltinsPropertiesNV;

The members of the VkPhysicalDeviceShaderSMBuiltinsPropertiesNV structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
shaderSMCount is the number of SMs on the device.
shaderWarpsPerSM is the maximum number of simultaneously executing warps on an SM.

If the VkPhysicalDeviceShaderSMBuiltinsPropertiesNV structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceShaderSMBuiltinsPropertiesNV-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV

The VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT structure is defined as:

typedef struct VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkDeviceSize       storageTexelBufferOffsetAlignmentBytes;
    VkBool32           storageTexelBufferOffsetSingleTexelAlignment;
    VkDeviceSize       uniformTexelBufferOffsetAlignmentBytes;
    VkBool32           uniformTexelBufferOffsetSingleTexelAlignment;
} VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT;

The members of the VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
storageTexelBufferOffsetAlignmentBytes is a byte alignment that is sufficient for a storage texel buffer of any format.
storageTexelBufferOffsetSingleTexelAlignment indicates whether single texel alignment is sufficient for a storage texel buffer of any format.
uniformTexelBufferOffsetAlignmentBytes is a byte alignment that is sufficient for a uniform texel buffer of any format.
uniformTexelBufferOffsetSingleTexelAlignment indicates whether single texel alignment is sufficient for a uniform texel buffer of any format.

If the VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

If the single texel alignment property is VK_FALSE, then the buffer view’s offset must be aligned to the corresponding byte alignment value. If the single texel alignment property is VK_TRUE, then the buffer view’s offset must be aligned to the lesser of the corresponding byte alignment value or the size of a single texel, based on VkBufferViewCreateInfo::format. If the size of a single texel is a multiple of three bytes, then the size of a single component of the format is used instead.

These limits must not advertise a larger alignment than the required maximum minimum value of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment, for any format that supports use as a texel buffer.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT

To query the timeline semaphore properties of a physical device, add a VkPhysicalDeviceTimelineSemaphoreProperties structure to the pNext chain of the VkPhysicalDeviceProperties2 structure. The VkPhysicalDeviceTimelineSemaphoreProperties structure is defined as:

typedef struct VkPhysicalDeviceTimelineSemaphoreProperties {
    VkStructureType    sType;
    void*              pNext;
    uint64_t           maxTimelineSemaphoreValueDifference;
} VkPhysicalDeviceTimelineSemaphoreProperties;

or the equivalent

typedef VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphorePropertiesKHR;

The members of the VkPhysicalDeviceTimelineSemaphoreProperties structure describe the following implementation-dependent limits:

maxTimelineSemaphoreValueDifference indicates the maximum difference allowed by the implementation between the current value of a timeline semaphore and any pending signal or wait operations.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceTimelineSemaphoreProperties-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES

The VkPhysicalDeviceLineRasterizationPropertiesEXT structure is defined as:

typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           lineSubPixelPrecisionBits;
} VkPhysicalDeviceLineRasterizationPropertiesEXT;

The members of the VkPhysicalDeviceLineRasterizationPropertiesEXT structure describe the following implementation-dependent limits:

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
lineSubPixelPrecisionBits is the number of bits of subpixel precision in framebuffer coordinates x_f and y_f when rasterizing line segments.

If the VkPhysicalDeviceLineRasterizationPropertiesEXT structure is included in the pNext chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceLineRasterizationPropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT

36.1. Limit Requirements

The following table specifies the required minimum/maximum for all Vulkan graphics implementations. Where a limit corresponds to a fine-grained device feature which is optional, the feature name is listed with two required limits, one when the feature is supported and one when it is not supported. If an implementation supports a feature, the limits reported are the same whether or not the feature is enabled.

Table 45. Required Limit Types
Type	Limit	Feature
`uint32_t`	`maxImageDimension1D`	-
`uint32_t`	`maxImageDimension2D`	-
`uint32_t`	`maxImageDimension3D`	-
`uint32_t`	`maxImageDimensionCube`	-
`uint32_t`	`maxImageArrayLayers`	-
`uint32_t`	`maxTexelBufferElements`	-
`uint32_t`	`maxUniformBufferRange`	-
`uint32_t`	`maxStorageBufferRange`	-
`uint32_t`	`maxPushConstantsSize`	-
`uint32_t`	`maxMemoryAllocationCount`	-
`uint32_t`	`maxSamplerAllocationCount`	-
`VkDeviceSize`	`bufferImageGranularity`	-
`VkDeviceSize`	`sparseAddressSpaceSize`	`sparseBinding`
`uint32_t`	`maxBoundDescriptorSets`	-
`uint32_t`	`maxPerStageDescriptorSamplers`	-
`uint32_t`	`maxPerStageDescriptorUniformBuffers`	-
`uint32_t`	`maxPerStageDescriptorStorageBuffers`	-
`uint32_t`	`maxPerStageDescriptorSampledImages`	-
`uint32_t`	`maxPerStageDescriptorStorageImages`	-
`uint32_t`	`maxPerStageDescriptorInputAttachments`	-
`uint32_t`	`maxPerStageResources`	-
`uint32_t`	`maxDescriptorSetSamplers`	-
`uint32_t`	`maxDescriptorSetUniformBuffers`	-
`uint32_t`	`maxDescriptorSetUniformBuffersDynamic`	-
`uint32_t`	`maxDescriptorSetStorageBuffers`	-
`uint32_t`	`maxDescriptorSetStorageBuffersDynamic`	-
`uint32_t`	`maxDescriptorSetSampledImages`	-
`uint32_t`	`maxDescriptorSetStorageImages`	-
`uint32_t`	`maxDescriptorSetInputAttachments`	-
`uint32_t`	`maxVertexInputAttributes`	-
`uint32_t`	`maxVertexInputBindings`	-
`uint32_t`	`maxVertexInputAttributeOffset`	-
`uint32_t`	`maxVertexInputBindingStride`	-
`uint32_t`	`maxVertexOutputComponents`	-
`uint32_t`	`maxTessellationGenerationLevel`	`tessellationShader`
`uint32_t`	`maxTessellationPatchSize`	`tessellationShader`
`uint32_t`	`maxTessellationControlPerVertexInputComponents`	`tessellationShader`
`uint32_t`	`maxTessellationControlPerVertexOutputComponents`	`tessellationShader`
`uint32_t`	`maxTessellationControlPerPatchOutputComponents`	`tessellationShader`
`uint32_t`	`maxTessellationControlTotalOutputComponents`	`tessellationShader`
`uint32_t`	`maxTessellationEvaluationInputComponents`	`tessellationShader`
`uint32_t`	`maxTessellationEvaluationOutputComponents`	`tessellationShader`
`uint32_t`	`maxGeometryShaderInvocations`	`geometryShader`
`uint32_t`	`maxGeometryInputComponents`	`geometryShader`
`uint32_t`	`maxGeometryOutputComponents`	`geometryShader`
`uint32_t`	`maxGeometryOutputVertices`	`geometryShader`
`uint32_t`	`maxGeometryTotalOutputComponents`	`geometryShader`
`uint32_t`	`maxFragmentInputComponents`	-
`uint32_t`	`maxFragmentOutputAttachments`	-
`uint32_t`	`maxFragmentDualSrcAttachments`	`dualSrcBlend`
`uint32_t`	`maxFragmentCombinedOutputResources`	-
`uint32_t`	`maxComputeSharedMemorySize`	-
3 × `uint32_t`	`maxComputeWorkGroupCount`	-
`uint32_t`	`maxComputeWorkGroupInvocations`	-
3 × `uint32_t`	`maxComputeWorkGroupSize`	-
`uint32_t`	`subPixelPrecisionBits`	-
`uint32_t`	`subTexelPrecisionBits`	-
`uint32_t`	`mipmapPrecisionBits`	-
`uint32_t`	`maxDrawIndexedIndexValue`	`fullDrawIndexUint32`
`uint32_t`	`maxDrawIndirectCount`	`multiDrawIndirect`
`float`	`maxSamplerLodBias`	-
`float`	`maxSamplerAnisotropy`	`samplerAnisotropy`
`uint32_t`	`maxViewports`	`multiViewport`
2 × `uint32_t`	`maxViewportDimensions`	-
2 × `float`	`viewportBoundsRange`	-
`uint32_t`	`viewportSubPixelBits`	-
`size_t`	`minMemoryMapAlignment`	-
`VkDeviceSize`	`minTexelBufferOffsetAlignment`	-
`VkDeviceSize`	`minUniformBufferOffsetAlignment`	-
`VkDeviceSize`	`minStorageBufferOffsetAlignment`	-
`int32_t`	`minTexelOffset`	-
`uint32_t`	`maxTexelOffset`	-
`int32_t`	`minTexelGatherOffset`	`shaderImageGatherExtended`
`uint32_t`	`maxTexelGatherOffset`	`shaderImageGatherExtended`
`float`	`minInterpolationOffset`	`sampleRateShading`
`float`	`maxInterpolationOffset`	`sampleRateShading`
`uint32_t`	`subPixelInterpolationOffsetBits`	`sampleRateShading`
`uint32_t`	`maxFramebufferWidth`	-
`uint32_t`	`maxFramebufferHeight`	-
`uint32_t`	`maxFramebufferLayers`	-
VkSampleCountFlags	`framebufferColorSampleCounts`	-
VkSampleCountFlags	`framebufferIntegerColorSampleCounts`	-
VkSampleCountFlags	`framebufferDepthSampleCounts`	-
VkSampleCountFlags	`framebufferStencilSampleCounts`	-
VkSampleCountFlags	`framebufferNoAttachmentsSampleCounts`	-
`uint32_t`	`maxColorAttachments`	-
VkSampleCountFlags	`sampledImageColorSampleCounts`	-
VkSampleCountFlags	`sampledImageIntegerSampleCounts`	-
VkSampleCountFlags	`sampledImageDepthSampleCounts`	-
VkSampleCountFlags	`sampledImageStencilSampleCounts`	-
VkSampleCountFlags	`storageImageSampleCounts`	`shaderStorageImageMultisample`
`uint32_t`	`maxSampleMaskWords`	-
`VkBool32`	`timestampComputeAndGraphics`	-
`float`	`timestampPeriod`	-
`uint32_t`	`maxClipDistances`	`shaderClipDistance`
`uint32_t`	`maxCullDistances`	`shaderCullDistance`
`uint32_t`	`maxCombinedClipAndCullDistances`	`shaderCullDistance`
`uint32_t`	`discreteQueuePriorities`	-
2 × `float`	`pointSizeRange`	`largePoints`
2 × `float`	`lineWidthRange`	`wideLines`
`float`	`pointSizeGranularity`	`largePoints`
`float`	`lineWidthGranularity`	`wideLines`
`VkBool32`	`strictLines`	-
`VkBool32`	`standardSampleLocations`	-
`VkDeviceSize`	`optimalBufferCopyOffsetAlignment`	-
`VkDeviceSize`	`optimalBufferCopyRowPitchAlignment`	-
`VkDeviceSize`	`nonCoherentAtomSize`	-
`uint32_t`	`maxDiscardRectangles`	`VK_EXT_discard_rectangles`
`VkBool32`	`filterMinmaxSingleComponentFormats`	`[VK_EXT_sampler_filter_minmax]`
`VkBool32`	`filterMinmaxImageComponentMapping`	`[VK_EXT_sampler_filter_minmax]`
`float`	`primitiveOverestimationSize`	`VK_EXT_conservative_rasterization`
`VkBool32`	`maxExtraPrimitiveOverestimationSize`	`VK_EXT_conservative_rasterization`
`float`	`extraPrimitiveOverestimationSizeGranularity`	`VK_EXT_conservative_rasterization`
`VkBool32`	`degenerateTriangleRasterized`	`VK_EXT_conservative_rasterization`
`float`	`degenerateLinesRasterized`	`VK_EXT_conservative_rasterization`
`VkBool32`	`fullyCoveredFragmentShaderInputVariable`	`VK_EXT_conservative_rasterization`
`VkBool32`	`conservativeRasterizationPostDepthCoverage`	`VK_EXT_conservative_rasterization`
`uint32_t`	`maxUpdateAfterBindDescriptorsInAllPools`	`descriptorIndexing`
`VkBool32`	`shaderUniformBufferArrayNonUniformIndexingNative`	-
`VkBool32`	`shaderSampledImageArrayNonUniformIndexingNative`	-
`VkBool32`	`shaderStorageBufferArrayNonUniformIndexingNative`	-
`VkBool32`	`shaderStorageImageArrayNonUniformIndexingNative`	-
`VkBool32`	`shaderInputAttachmentArrayNonUniformIndexingNative`	-
`uint32_t`	`maxPerStageDescriptorUpdateAfterBindSamplers`	`descriptorIndexing`
`uint32_t`	`maxPerStageDescriptorUpdateAfterBindUniformBuffers`	`descriptorIndexing`
`uint32_t`	`maxPerStageDescriptorUpdateAfterBindStorageBuffers`	`descriptorIndexing`
`uint32_t`	`maxPerStageDescriptorUpdateAfterBindSampledImages`	`descriptorIndexing`
`uint32_t`	`maxPerStageDescriptorUpdateAfterBindStorageImages`	`descriptorIndexing`
`uint32_t`	`maxPerStageDescriptorUpdateAfterBindInputAttachments`	`descriptorIndexing`
`uint32_t`	`maxPerStageUpdateAfterBindResources`	`descriptorIndexing`
`uint32_t`	`maxDescriptorSetUpdateAfterBindSamplers`	`descriptorIndexing`
`uint32_t`	`maxDescriptorSetUpdateAfterBindUniformBuffers`	`descriptorIndexing`
`uint32_t`	`maxDescriptorSetUpdateAfterBindUniformBuffersDynamic`	`descriptorIndexing`
`uint32_t`	`maxDescriptorSetUpdateAfterBindStorageBuffers`	`descriptorIndexing`
`uint32_t`	`maxDescriptorSetUpdateAfterBindStorageBuffersDynamic`	`descriptorIndexing`
`uint32_t`	`maxDescriptorSetUpdateAfterBindSampledImages`	`descriptorIndexing`
`uint32_t`	`maxDescriptorSetUpdateAfterBindStorageImages`	`descriptorIndexing`
`uint32_t`	`maxDescriptorSetUpdateAfterBindInputAttachments`	`descriptorIndexing`
`uint32_t`	`maxVertexAttribDivisor`	`VK_EXT_vertex_attribute_divisor`
`uint32_t`	`maxDrawMeshTasksCount`	`VK_NV_mesh_shader`
`uint32_t`	`maxTaskWorkGroupInvocations`	`VK_NV_mesh_shader`
`uint32_t`	`maxTaskWorkGroupSize`	`VK_NV_mesh_shader`
`uint32_t`	`maxTaskTotalMemorySize`	`VK_NV_mesh_shader`
`uint32_t`	`maxTaskOutputCount`	`VK_NV_mesh_shader`
`uint32_t`	`maxMeshWorkGroupInvocations`	`VK_NV_mesh_shader`
`uint32_t`	`maxMeshWorkGroupSize`	`VK_NV_mesh_shader`
`uint32_t`	`maxMeshTotalMemorySize`	`VK_NV_mesh_shader`
`uint32_t`	`maxMeshOutputVertices`	`VK_NV_mesh_shader`
`uint32_t`	`maxMeshOutputPrimitives`	`VK_NV_mesh_shader`
`uint32_t`	`maxMeshMultiviewViewCount`	`VK_NV_mesh_shader`
`uint32_t`	`meshOutputPerVertexGranularity`	`VK_NV_mesh_shader`
`uint32_t`	`meshOutputPerPrimitiveGranularity`	`VK_NV_mesh_shader`
`uint32_t`	`maxTransformFeedbackStreams`	`VK_EXT_transform_feedback`
`uint32_t`	`maxTransformFeedbackBuffers`	`VK_EXT_transform_feedback`
`VkDeviceSize`	`maxTransformFeedbackBufferSize`	`VK_EXT_transform_feedback`
`uint32_t`	`maxTransformFeedbackStreamDataSize`	`VK_EXT_transform_feedback`
`uint32_t`	`maxTransformFeedbackBufferDataSize`	`VK_EXT_transform_feedback`
`uint32_t`	`maxTransformFeedbackBufferDataStride`	`VK_EXT_transform_feedback`
`VkBool32`	`transformFeedbackQueries`	`VK_EXT_transform_feedback`
`VkBool32`	`transformFeedbackStreamsLinesTriangles`	`VK_EXT_transform_feedback`
`VkBool32`	`transformFeedbackRasterizationStreamSelect`	`VK_EXT_transform_feedback`
`VkBool32`	`transformFeedbackDraw`	`VK_EXT_transform_feedback`
VkExtent2D	`minFragmentDensityTexelSize`	`fragmentDensityMap`
VkExtent2D	`maxFragmentDensityTexelSize`	`fragmentDensityMap`
`VkBool32`	`fragmentDensityInvocations`	`fragmentDensityMap`
`uint32_t`	`shaderGroupHandleSize`	`VK_NV_ray_tracing`
`uint32_t`	`maxRecursionDepth`	`VK_NV_ray_tracing`
`uint32_t`	`shaderGroupBaseAlignment`	`VK_NV_ray_tracing`
`uint32_t`	`maxGeometryCount`	`VK_NV_ray_tracing`
`uint32_t`	`maxInstanceCount`	`VK_NV_ray_tracing`
`uint32_t`	`maxTriangleCount`	`VK_NV_ray_tracing`
`uint32_t`	`maxDescriptorSetAccelerationStructures`	`VK_NV_ray_tracing`
`uint64_t`	`maxTimelineSemaphoreValueDifference`	`timelineSemaphore`
`uint32_t`	`lineSubPixelPrecisionBits`	`VK_EXT_line_rasterization`

Table 46. Required Limits
Limit	Unsupported Limit	Supported Limit	Limit Type¹
`maxImageDimension1D`	-	4096	min
`maxImageDimension2D`	-	4096	min
`maxImageDimension3D`	-	256	min
`maxImageDimensionCube`	-	4096	min
`maxImageArrayLayers`	-	256	min
`maxTexelBufferElements`	-	65536	min
`maxUniformBufferRange`	-	16384	min
`maxStorageBufferRange`	-	2²⁷	min
`maxPushConstantsSize`	-	128	min
`maxMemoryAllocationCount`	-	4096	min
`maxSamplerAllocationCount`	-	4000	min
`bufferImageGranularity`	-	131072	max
`sparseAddressSpaceSize`	0	2³¹	min
`maxBoundDescriptorSets`	-	4	min
`maxPerStageDescriptorSamplers`	-	16	min
`maxPerStageDescriptorUniformBuffers`	-	12	min
`maxPerStageDescriptorStorageBuffers`	-	4	min
`maxPerStageDescriptorSampledImages`	-	16	min
`maxPerStageDescriptorStorageImages`	-	4	min
`maxPerStageDescriptorInputAttachments`	-	4	min
`maxPerStageResources`	-	128 ²	min
`maxDescriptorSetSamplers`	-	96 ⁸	min, n × PerStage
`maxDescriptorSetUniformBuffers`	-	72 ⁸	min, n × PerStage
`maxDescriptorSetUniformBuffersDynamic`	-	8	min
`maxDescriptorSetStorageBuffers`	-	24 ⁸	min, n × PerStage
`maxDescriptorSetStorageBuffersDynamic`	-	4	min
`maxDescriptorSetSampledImages`	-	96 ⁸	min, n × PerStage
`maxDescriptorSetStorageImages`	-	24 ⁸	min, n × PerStage
`maxDescriptorSetInputAttachments`	-	4	min
`maxVertexInputAttributes`	-	16	min
`maxVertexInputBindings`	-	16	min
`maxVertexInputAttributeOffset`	-	2047	min
`maxVertexInputBindingStride`	-	2048	min
`maxVertexOutputComponents`	-	64	min
`maxTessellationGenerationLevel`	0	64	min
`maxTessellationPatchSize`	0	32	min
`maxTessellationControlPerVertexInputComponents`	0	64	min
`maxTessellationControlPerVertexOutputComponents`	0	64	min
`maxTessellationControlPerPatchOutputComponents`	0	120	min
`maxTessellationControlTotalOutputComponents`	0	2048	min
`maxTessellationEvaluationInputComponents`	0	64	min
`maxTessellationEvaluationOutputComponents`	0	64	min
`maxGeometryShaderInvocations`	0	32	min
`maxGeometryInputComponents`	0	64	min
`maxGeometryOutputComponents`	0	64	min
`maxGeometryOutputVertices`	0	256	min
`maxGeometryTotalOutputComponents`	0	1024	min
`maxFragmentInputComponents`	-	64	min
`maxFragmentOutputAttachments`	-	4	min
`maxFragmentDualSrcAttachments`	0	1	min
`maxFragmentCombinedOutputResources`	-	4	min
`maxComputeSharedMemorySize`	-	16384	min
`maxComputeWorkGroupCount`	-	(65535,65535,65535)	min
`maxComputeWorkGroupInvocations`	-	128	min
`maxComputeWorkGroupSize`	-	(128,128,64)	min
`subPixelPrecisionBits`	-	4	min
`subTexelPrecisionBits`	-	4	min
`mipmapPrecisionBits`	-	4	min
`maxDrawIndexedIndexValue`	2²⁴-1	2³²-1	min
`maxDrawIndirectCount`	1	2¹⁶-1	min
`maxSamplerLodBias`	-	2	min
`maxSamplerAnisotropy`	1	16	min
`maxViewports`	1	16	min
`maxViewportDimensions`	-	(4096,4096) ³	min
`viewportBoundsRange`	-	(-8192,8191) ⁴	(max,min)
`viewportSubPixelBits`	-	0	min
`minMemoryMapAlignment`	-	64	min
`minTexelBufferOffsetAlignment`	-	256	max
`minUniformBufferOffsetAlignment`	-	256	max
`minStorageBufferOffsetAlignment`	-	256	max
`minTexelOffset`	-	-8	max
`maxTexelOffset`	-	7	min
`minTexelGatherOffset`	0	-8	max
`maxTexelGatherOffset`	0	7	min
`minInterpolationOffset`	0.0	-0.5 ⁵	max
`maxInterpolationOffset`	0.0	0.5 - (1 ULP) ⁵	min
`subPixelInterpolationOffsetBits`	0	4 ⁵	min
`maxFramebufferWidth`	-	4096	min
`maxFramebufferHeight`	-	4096	min
`maxFramebufferLayers`	-	256	min
`framebufferColorSampleCounts`	-	(`VK_SAMPLE_COUNT_1_BIT` \| `VK_SAMPLE_COUNT_4_BIT`)	min
`framebufferIntegerColorSampleCounts`	-	(`VK_SAMPLE_COUNT_1_BIT`)	min
`framebufferDepthSampleCounts`	-	(`VK_SAMPLE_COUNT_1_BIT` \| `VK_SAMPLE_COUNT_4_BIT`)	min
`framebufferStencilSampleCounts`	-	(`VK_SAMPLE_COUNT_1_BIT` \| `VK_SAMPLE_COUNT_4_BIT`)	min
`framebufferNoAttachmentsSampleCounts`	-	(`VK_SAMPLE_COUNT_1_BIT` \| `VK_SAMPLE_COUNT_4_BIT`)	min
`maxColorAttachments`	-	4	min
`sampledImageColorSampleCounts`	-	(`VK_SAMPLE_COUNT_1_BIT` \| `VK_SAMPLE_COUNT_4_BIT`)	min
`sampledImageIntegerSampleCounts`	-	`VK_SAMPLE_COUNT_1_BIT`	min
`sampledImageDepthSampleCounts`	-	(`VK_SAMPLE_COUNT_1_BIT` \| `VK_SAMPLE_COUNT_4_BIT`)	min
`sampledImageStencilSampleCounts`	-	(`VK_SAMPLE_COUNT_1_BIT` \| `VK_SAMPLE_COUNT_4_BIT`)	min
`storageImageSampleCounts`	`VK_SAMPLE_COUNT_1_BIT`	(`VK_SAMPLE_COUNT_1_BIT` \| `VK_SAMPLE_COUNT_4_BIT`)	min
`maxSampleMaskWords`	-	1	min
`timestampComputeAndGraphics`	-	-	implementation dependent
`timestampPeriod`	-	-	duration
`maxClipDistances`	0	8	min
`maxCullDistances`	0	8	min
`maxCombinedClipAndCullDistances`	0	8	min
`discreteQueuePriorities`	-	2	min
`pointSizeRange`	(1.0,1.0)	(1.0,64.0 - ULP)⁶	(max,min)
`lineWidthRange`	(1.0,1.0)	(1.0,8.0 - ULP)⁷	(max,min)
`pointSizeGranularity`	0.0	1.0 ⁶	max, fixed point increment
`lineWidthGranularity`	0.0	1.0 ⁷	max, fixed point increment
`strictLines`	-	-	implementation dependent
`standardSampleLocations`	-	-	implementation dependent
`optimalBufferCopyOffsetAlignment`	-	-	recommendation
`optimalBufferCopyRowPitchAlignment`	-	-	recommendation
`nonCoherentAtomSize`	-	256	max
`maxPushDescriptors`	-	32	min
`maxMultiviewViewCount`	-	6	min
`maxMultiviewInstanceIndex`	-	2²⁷-1	min
`maxDiscardRectangles`	0	4	min
`sampleLocationSampleCounts`	-	`VK_SAMPLE_COUNT_4_BIT`	min
`maxSampleLocationGridSize`	-	(1,1)	min
`sampleLocationCoordinateRange`	-	(0.0, 0.9375)	(max,min)
`sampleLocationSubPixelBits`	-	4	min
`variableSampleLocations`	-	false	implementation dependent
`minImportedHostPointerAlignment`	-	65536	max
`perViewPositionAllComponents`	-	-	implementation dependent
`filterMinmaxSingleComponentFormats`	-	-	implementation dependent
`filterMinmaxImageComponentMapping`	-	-	implementation dependent
`advancedBlendMaxColorAttachments`	-	1	min
`advancedBlendIndependentBlend`	-	false	implementation dependent
`advancedBlendNonPremultipliedSrcColor`	-	false	implementation dependent
`advancedBlendNonPremultipliedDstColor`	-	false	implementation dependent
`advancedBlendCorrelatedOverlap`	-	false	implementation dependent
`advancedBlendAllOperations`	-	false	implementation dependent
`maxPerSetDescriptors`	-	1024	min
`maxMemoryAllocationSize`	-	2³⁰	min
`primitiveOverestimationSize`	-	0.0	min
`maxExtraPrimitiveOverestimationSize`	-	0.0	min
`extraPrimitiveOverestimationSizeGranularity`	-	0.0	min
`primitiveUnderestimation`	-	false	implementation dependent
`conservativePointAndLineRasterization`	-	false	implementation dependent
`degenerateTrianglesRasterized`	-	false	implementation dependent
`degenerateLinesRasterized`	-	false	implementation dependent
`fullyCoveredFragmentShaderInputVariable`	-	false	implementation dependent
`conservativeRasterizationPostDepthCoverage`	-	false	implementation dependent
`maxUpdateAfterBindDescriptorsInAllPools`	0	500000	min
`shaderUniformBufferArrayNonUniformIndexingNative`	-	false	implementation dependent
`shaderSampledImageArrayNonUniformIndexingNative`	-	false	implementation dependent
`shaderStorageBufferArrayNonUniformIndexingNative`	-	false	implementation dependent
`shaderStorageImageArrayNonUniformIndexingNative`	-	false	implementation dependent
`shaderInputAttachmentArrayNonUniformIndexingNative`	-	false	implementation dependent
`maxPerStageDescriptorUpdateAfterBindSamplers`	0	500000 ⁹	min
`maxPerStageDescriptorUpdateAfterBindUniformBuffers`	0	12 ⁹	min
`maxPerStageDescriptorUpdateAfterBindStorageBuffers`	0	500000 ⁹	min
`maxPerStageDescriptorUpdateAfterBindSampledImages`	0	500000 ⁹	min
`maxPerStageDescriptorUpdateAfterBindStorageImages`	0	500000 ⁹	min
`maxPerStageDescriptorUpdateAfterBindInputAttachments`	0	4 ⁹	min
`maxPerStageUpdateAfterBindResources`	0	500000 ⁹	min
`maxDescriptorSetUpdateAfterBindSamplers`	0	500000 ⁹	min
`maxDescriptorSetUpdateAfterBindUniformBuffers`	0	72 ⁸ ⁹	min, n × PerStage
`maxDescriptorSetUpdateAfterBindUniformBuffersDynamic`	0	8 ⁹	min
`maxDescriptorSetUpdateAfterBindStorageBuffers`	0	500000 ⁹	min
`maxDescriptorSetUpdateAfterBindStorageBuffersDynamic`	0	4 ⁹	min
`maxDescriptorSetUpdateAfterBindSampledImages`	0	500000 ⁹	min
`maxDescriptorSetUpdateAfterBindStorageImages`	0	500000 ⁹	min
`maxDescriptorSetUpdateAfterBindInputAttachments`	0	4 ⁹	min
`maxInlineUniformBlockSize`	-	256	min
`maxPerStageDescriptorInlineUniformBlocks`	-	4	min
`maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks`	-	4	min
`maxDescriptorSetInlineUniformBlocks`	-	4	min
`maxDescriptorSetUpdateAfterBindInlineUniformBlocks`	-	4	min
`maxVertexAttribDivisor`	-	2¹⁶-1	min
`maxDrawMeshTasksCount`	-	2¹⁶-1	min
`maxTaskWorkGroupInvocations`	-	32	min
`maxTaskWorkGroupSize`	-	(32,1,1)	min
`maxTaskTotalMemorySize`	-	16384	min
`maxTaskOutputCount`	-	2¹⁶-1	min
`maxMeshWorkGroupInvocations`	-	32	min
`maxMeshWorkGroupSize`	-	(32,1,1)	min
`maxMeshTotalMemorySize`	-	16384	min
`maxMeshOutputVertices`	-	256	min
`maxMeshOutputPrimitives`	-	256	min
`maxMeshMultiviewViewCount`	-	1	min
`meshOutputPerVertexGranularity`	-	-	implementation dependent
`meshOutputPerPrimitiveGranularity`	-	-	implementation dependent
`maxTransformFeedbackStreams`	-	1	min
`maxTransformFeedbackBuffers`	-	1	min
`maxTransformFeedbackBufferSize`	-	2²⁷	min
`maxTransformFeedbackStreamDataSize`	-	512	min
`maxTransformFeedbackBufferDataSize`	-	512	min
`maxTransformFeedbackBufferDataStride`	-	512	min
`transformFeedbackQueries`	-	false	implementation dependent
`transformFeedbackStreamsLinesTriangles`	-	false	implementation dependent
`transformFeedbackRasterizationStreamSelect`	-	false	implementation dependent
`transformFeedbackDraw`	-	false	implementation dependent
`minFragmentDensityTexelSize`	-	(1,1)	min
`maxFragmentDensityTexelSize`	-	(1,1)	min
`fragmentDensityInvocations`	-	-	implementation dependent
`shaderGroupHandleSize`	-	16	min
`maxRecursionDepth`	-	31	min
`shaderGroupBaseAlignment`	-	64	max
`maxGeometryCount`	-	2²⁴-1	min
`maxInstanceCount`	-	2²⁴-1	min
`maxTriangleCount`	-	2²⁹-1	min
`maxDescriptorSetAccelerationStructures`	-	16	min
`maxTimelineSemaphoreValueDifference`	-	2³¹-1	min
`lineSubPixelPrecisionBits`	-	4	min

1

The Limit Type column specifies the limit is either the minimum limit all implementations must support or the maximum limit all implementations must support. For bitmasks a minimum limit is the least bits all implementations must set, but they may have additional bits set beyond this minimum.

2

The maxPerStageResources must be at least the smallest of the following:

the sum of the maxPerStageDescriptorUniformBuffers, maxPerStageDescriptorStorageBuffers, maxPerStageDescriptorSampledImages, maxPerStageDescriptorStorageImages, maxPerStageDescriptorInputAttachments, maxColorAttachments limits, or
128.

It may not be possible to reach this limit in every stage.

3

See maxViewportDimensions for the required relationship to other limits.

4

See viewportBoundsRange for the required relationship to other limits.

5

The values minInterpolationOffset and maxInterpolationOffset describe the closed interval of supported interpolation offsets: [minInterpolationOffset, maxInterpolationOffset]. The ULP is determined by subPixelInterpolationOffsetBits. If subPixelInterpolationOffsetBits is 4, this provides increments of (1/2⁴) = 0.0625, and thus the range of supported interpolation offsets would be [-0.5, 0.4375].

6

The point size ULP is determined by pointSizeGranularity. If the pointSizeGranularity is 0.125, the range of supported point sizes must be at least [1.0, 63.875].

7

The line width ULP is determined by lineWidthGranularity. If the lineWidthGranularity is 0.0625, the range of supported line widths must be at least [1.0, 7.9375].

8

The minimum maxDescriptorSet* limit is n times the corresponding specification minimum maxPerStageDescriptor* limit, where n is the number of shader stages supported by the VkPhysicalDevice. If all shader stages are supported, n = 6 (vertex, tessellation control, tessellation evaluation, geometry, fragment, compute).

9

The UpdateAfterBind descriptor limits must each be greater than or equal to the corresponding non-UpdateAfterBind limit.

36.2. Additional Multisampling Capabilities

In addition to the minimum capabilities described for (Limits) above, implementations may support additional multisampling capabilities specific to a particular sample count.

To query additional sample count specific multisampling capabilities, call:

void vkGetPhysicalDeviceMultisamplePropertiesEXT(
    VkPhysicalDevice                            physicalDevice,
    VkSampleCountFlagBits                       samples,
    VkMultisamplePropertiesEXT*                 pMultisampleProperties);

physicalDevice is the physical device from which to query the additional multisampling capabilities.
samples is the sample count to query the capabilities for.
pMultisampleProperties is a pointer to a VkMultisamplePropertiesEXT structure in which information about the additional multisampling capabilities specific to the sample count is returned.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-samples-parameter
samples must be a valid VkSampleCountFlagBits value
VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-pMultisampleProperties-parameter
pMultisampleProperties must be a valid pointer to a VkMultisamplePropertiesEXT structure

The VkMultisamplePropertiesEXT structure is defined as

typedef struct VkMultisamplePropertiesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkExtent2D         maxSampleLocationGridSize;
} VkMultisamplePropertiesEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
maxSampleLocationGridSize is the maximum size of the pixel grid in which sample locations can vary.

Valid Usage (Implicit)

VUID-VkMultisamplePropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT
VUID-VkMultisamplePropertiesEXT-pNext-pNext
pNext must be NULL

If the sample count for which additional multisampling capabilities are requested using vkGetPhysicalDeviceMultisamplePropertiesEXT is set in VkPhysicalDeviceSampleLocationsPropertiesEXT:: sampleLocationSampleCounts the width and height members of VkMultisamplePropertiesEXT::maxSampleLocationGridSize must be greater than or equal to the corresponding members of VkPhysicalDeviceSampleLocationsPropertiesEXT:: maxSampleLocationGridSize, respectively, otherwise both members must be 0.

37. Formats

Supported buffer and image formats may vary across implementations. A minimum set of format features are guaranteed, but others must be explicitly queried before use to ensure they are supported by the implementation.

The features for the set of formats (VkFormat) supported by the implementation are queried individually using the vkGetPhysicalDeviceFormatProperties command.

37.1. Format Definition

The following image formats can be passed to, and may be returned from Vulkan commands. The memory required to store each format is discussed with that format, and also summarized in the Representation and Texel Block Size section and the Compatible formats table.

typedef enum VkFormat {
    VK_FORMAT_UNDEFINED = 0,
    VK_FORMAT_R4G4_UNORM_PACK8 = 1,
    VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
    VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
    VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
    VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
    VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
    VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
    VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
    VK_FORMAT_R8_UNORM = 9,
    VK_FORMAT_R8_SNORM = 10,
    VK_FORMAT_R8_USCALED = 11,
    VK_FORMAT_R8_SSCALED = 12,
    VK_FORMAT_R8_UINT = 13,
    VK_FORMAT_R8_SINT = 14,
    VK_FORMAT_R8_SRGB = 15,
    VK_FORMAT_R8G8_UNORM = 16,
    VK_FORMAT_R8G8_SNORM = 17,
    VK_FORMAT_R8G8_USCALED = 18,
    VK_FORMAT_R8G8_SSCALED = 19,
    VK_FORMAT_R8G8_UINT = 20,
    VK_FORMAT_R8G8_SINT = 21,
    VK_FORMAT_R8G8_SRGB = 22,
    VK_FORMAT_R8G8B8_UNORM = 23,
    VK_FORMAT_R8G8B8_SNORM = 24,
    VK_FORMAT_R8G8B8_USCALED = 25,
    VK_FORMAT_R8G8B8_SSCALED = 26,
    VK_FORMAT_R8G8B8_UINT = 27,
    VK_FORMAT_R8G8B8_SINT = 28,
    VK_FORMAT_R8G8B8_SRGB = 29,
    VK_FORMAT_B8G8R8_UNORM = 30,
    VK_FORMAT_B8G8R8_SNORM = 31,
    VK_FORMAT_B8G8R8_USCALED = 32,
    VK_FORMAT_B8G8R8_SSCALED = 33,
    VK_FORMAT_B8G8R8_UINT = 34,
    VK_FORMAT_B8G8R8_SINT = 35,
    VK_FORMAT_B8G8R8_SRGB = 36,
    VK_FORMAT_R8G8B8A8_UNORM = 37,
    VK_FORMAT_R8G8B8A8_SNORM = 38,
    VK_FORMAT_R8G8B8A8_USCALED = 39,
    VK_FORMAT_R8G8B8A8_SSCALED = 40,
    VK_FORMAT_R8G8B8A8_UINT = 41,
    VK_FORMAT_R8G8B8A8_SINT = 42,
    VK_FORMAT_R8G8B8A8_SRGB = 43,
    VK_FORMAT_B8G8R8A8_UNORM = 44,
    VK_FORMAT_B8G8R8A8_SNORM = 45,
    VK_FORMAT_B8G8R8A8_USCALED = 46,
    VK_FORMAT_B8G8R8A8_SSCALED = 47,
    VK_FORMAT_B8G8R8A8_UINT = 48,
    VK_FORMAT_B8G8R8A8_SINT = 49,
    VK_FORMAT_B8G8R8A8_SRGB = 50,
    VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
    VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
    VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
    VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
    VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
    VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
    VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
    VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
    VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
    VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
    VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
    VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
    VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
    VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
    VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
    VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
    VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
    VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
    VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
    VK_FORMAT_R16_UNORM = 70,
    VK_FORMAT_R16_SNORM = 71,
    VK_FORMAT_R16_USCALED = 72,
    VK_FORMAT_R16_SSCALED = 73,
    VK_FORMAT_R16_UINT = 74,
    VK_FORMAT_R16_SINT = 75,
    VK_FORMAT_R16_SFLOAT = 76,
    VK_FORMAT_R16G16_UNORM = 77,
    VK_FORMAT_R16G16_SNORM = 78,
    VK_FORMAT_R16G16_USCALED = 79,
    VK_FORMAT_R16G16_SSCALED = 80,
    VK_FORMAT_R16G16_UINT = 81,
    VK_FORMAT_R16G16_SINT = 82,
    VK_FORMAT_R16G16_SFLOAT = 83,
    VK_FORMAT_R16G16B16_UNORM = 84,
    VK_FORMAT_R16G16B16_SNORM = 85,
    VK_FORMAT_R16G16B16_USCALED = 86,
    VK_FORMAT_R16G16B16_SSCALED = 87,
    VK_FORMAT_R16G16B16_UINT = 88,
    VK_FORMAT_R16G16B16_SINT = 89,
    VK_FORMAT_R16G16B16_SFLOAT = 90,
    VK_FORMAT_R16G16B16A16_UNORM = 91,
    VK_FORMAT_R16G16B16A16_SNORM = 92,
    VK_FORMAT_R16G16B16A16_USCALED = 93,
    VK_FORMAT_R16G16B16A16_SSCALED = 94,
    VK_FORMAT_R16G16B16A16_UINT = 95,
    VK_FORMAT_R16G16B16A16_SINT = 96,
    VK_FORMAT_R16G16B16A16_SFLOAT = 97,
    VK_FORMAT_R32_UINT = 98,
    VK_FORMAT_R32_SINT = 99,
    VK_FORMAT_R32_SFLOAT = 100,
    VK_FORMAT_R32G32_UINT = 101,
    VK_FORMAT_R32G32_SINT = 102,
    VK_FORMAT_R32G32_SFLOAT = 103,
    VK_FORMAT_R32G32B32_UINT = 104,
    VK_FORMAT_R32G32B32_SINT = 105,
    VK_FORMAT_R32G32B32_SFLOAT = 106,
    VK_FORMAT_R32G32B32A32_UINT = 107,
    VK_FORMAT_R32G32B32A32_SINT = 108,
    VK_FORMAT_R32G32B32A32_SFLOAT = 109,
    VK_FORMAT_R64_UINT = 110,
    VK_FORMAT_R64_SINT = 111,
    VK_FORMAT_R64_SFLOAT = 112,
    VK_FORMAT_R64G64_UINT = 113,
    VK_FORMAT_R64G64_SINT = 114,
    VK_FORMAT_R64G64_SFLOAT = 115,
    VK_FORMAT_R64G64B64_UINT = 116,
    VK_FORMAT_R64G64B64_SINT = 117,
    VK_FORMAT_R64G64B64_SFLOAT = 118,
    VK_FORMAT_R64G64B64A64_UINT = 119,
    VK_FORMAT_R64G64B64A64_SINT = 120,
    VK_FORMAT_R64G64B64A64_SFLOAT = 121,
    VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
    VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
    VK_FORMAT_D16_UNORM = 124,
    VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
    VK_FORMAT_D32_SFLOAT = 126,
    VK_FORMAT_S8_UINT = 127,
    VK_FORMAT_D16_UNORM_S8_UINT = 128,
    VK_FORMAT_D24_UNORM_S8_UINT = 129,
    VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
    VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
    VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
    VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
    VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
    VK_FORMAT_BC2_UNORM_BLOCK = 135,
    VK_FORMAT_BC2_SRGB_BLOCK = 136,
    VK_FORMAT_BC3_UNORM_BLOCK = 137,
    VK_FORMAT_BC3_SRGB_BLOCK = 138,
    VK_FORMAT_BC4_UNORM_BLOCK = 139,
    VK_FORMAT_BC4_SNORM_BLOCK = 140,
    VK_FORMAT_BC5_UNORM_BLOCK = 141,
    VK_FORMAT_BC5_SNORM_BLOCK = 142,
    VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
    VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
    VK_FORMAT_BC7_UNORM_BLOCK = 145,
    VK_FORMAT_BC7_SRGB_BLOCK = 146,
    VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
    VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
    VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
    VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
    VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
    VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
    VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
    VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
    VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
    VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
    VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
    VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
    VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
    VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
    VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
    VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
    VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
    VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
    VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
    VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
    VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
    VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
    VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
    VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
    VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
    VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
    VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
    VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
    VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
    VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
    VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
    VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
    VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
    VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
    VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
    VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
    VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
    VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
    VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000,
    VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001,
    VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002,
    VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003,
    VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004,
    VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005,
    VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006,
    VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007,
    VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008,
    VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009,
    VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010,
    VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011,
    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012,
    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013,
    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014,
    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015,
    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016,
    VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017,
    VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018,
    VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019,
    VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020,
    VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021,
    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022,
    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023,
    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024,
    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025,
    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026,
    VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027,
    VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028,
    VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029,
    VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030,
    VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031,
    VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032,
    VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033,
    VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
    VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
    VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
    VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
    VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
    VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
    VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
    VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
    VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = 1000066000,
    VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = 1000066001,
    VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = 1000066002,
    VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = 1000066003,
    VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = 1000066004,
    VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = 1000066005,
    VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = 1000066006,
    VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = 1000066007,
    VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = 1000066008,
    VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = 1000066009,
    VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = 1000066010,
    VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = 1000066011,
    VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = 1000066012,
    VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = 1000066013,
    VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM,
    VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM,
    VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
    VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
    VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
    VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
    VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
    VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16,
    VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
    VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
    VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
    VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
    VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16,
    VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
    VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
    VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
    VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
    VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM,
    VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM,
    VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
    VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
    VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
    VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
    VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,
    VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
} VkFormat;

VK_FORMAT_UNDEFINED specifies that the format is not specified.
VK_FORMAT_R4G4_UNORM_PACK8 specifies 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.
VK_FORMAT_R4G4B4A4_UNORM_PACK16 specifies 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.
VK_FORMAT_B4G4R4A4_UNORM_PACK16 specifies 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.
VK_FORMAT_R5G6B5_UNORM_PACK16 specifies 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.
VK_FORMAT_B5G6R5_UNORM_PACK16 specifies 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.
VK_FORMAT_R5G5B5A1_UNORM_PACK16 specifies 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.
VK_FORMAT_B5G5R5A1_UNORM_PACK16 specifies 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.
VK_FORMAT_A1R5G5B5_UNORM_PACK16 specifies 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.
VK_FORMAT_R8_UNORM specifies a one-component, 8-bit unsigned normalized format that has a single 8-bit R component.
VK_FORMAT_R8_SNORM specifies a one-component, 8-bit signed normalized format that has a single 8-bit R component.
VK_FORMAT_R8_USCALED specifies a one-component, 8-bit unsigned scaled integer format that has a single 8-bit R component.
VK_FORMAT_R8_SSCALED specifies a one-component, 8-bit signed scaled integer format that has a single 8-bit R component.
VK_FORMAT_R8_UINT specifies a one-component, 8-bit unsigned integer format that has a single 8-bit R component.
VK_FORMAT_R8_SINT specifies a one-component, 8-bit signed integer format that has a single 8-bit R component.
VK_FORMAT_R8_SRGB specifies a one-component, 8-bit unsigned normalized format that has a single 8-bit R component stored with sRGB nonlinear encoding.
VK_FORMAT_R8G8_UNORM specifies 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.
VK_FORMAT_R8G8_SNORM specifies 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.
VK_FORMAT_R8G8_USCALED specifies 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.
VK_FORMAT_R8G8_SSCALED specifies 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.
VK_FORMAT_R8G8_UINT specifies 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.
VK_FORMAT_R8G8_SINT specifies 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.
VK_FORMAT_R8G8_SRGB specifies 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.
VK_FORMAT_R8G8B8_UNORM specifies 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.
VK_FORMAT_R8G8B8_SNORM specifies 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.
VK_FORMAT_R8G8B8_USCALED specifies 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.
VK_FORMAT_R8G8B8_SSCALED specifies 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.
VK_FORMAT_R8G8B8_UINT specifies 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.
VK_FORMAT_R8G8B8_SINT specifies 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.
VK_FORMAT_R8G8B8_SRGB specifies 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.
VK_FORMAT_B8G8R8_UNORM specifies 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.
VK_FORMAT_B8G8R8_SNORM specifies 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.
VK_FORMAT_B8G8R8_USCALED specifies 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.
VK_FORMAT_B8G8R8_SSCALED specifies 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.
VK_FORMAT_B8G8R8_UINT specifies 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.
VK_FORMAT_B8G8R8_SINT specifies 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.
VK_FORMAT_B8G8R8_SRGB specifies 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.
VK_FORMAT_R8G8B8A8_UNORM specifies 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.
VK_FORMAT_R8G8B8A8_SNORM specifies 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.
VK_FORMAT_R8G8B8A8_USCALED specifies 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.
VK_FORMAT_R8G8B8A8_SSCALED specifies 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.
VK_FORMAT_R8G8B8A8_UINT specifies 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.
VK_FORMAT_R8G8B8A8_SINT specifies 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.
VK_FORMAT_R8G8B8A8_SRGB specifies 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.
VK_FORMAT_B8G8R8A8_UNORM specifies 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.
VK_FORMAT_B8G8R8A8_SNORM specifies 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.
VK_FORMAT_B8G8R8A8_USCALED specifies 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.
VK_FORMAT_B8G8R8A8_SSCALED specifies 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.
VK_FORMAT_B8G8R8A8_UINT specifies 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.
VK_FORMAT_B8G8R8A8_SINT specifies 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.
VK_FORMAT_B8G8R8A8_SRGB specifies 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.
VK_FORMAT_A8B8G8R8_UNORM_PACK32 specifies 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.
VK_FORMAT_A8B8G8R8_SNORM_PACK32 specifies 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.
VK_FORMAT_A8B8G8R8_USCALED_PACK32 specifies 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.
VK_FORMAT_A8B8G8R8_SSCALED_PACK32 specifies 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.
VK_FORMAT_A8B8G8R8_UINT_PACK32 specifies 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.
VK_FORMAT_A8B8G8R8_SINT_PACK32 specifies 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.
VK_FORMAT_A8B8G8R8_SRGB_PACK32 specifies 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.
VK_FORMAT_A2R10G10B10_UNORM_PACK32 specifies 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.
VK_FORMAT_A2R10G10B10_SNORM_PACK32 specifies 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.
VK_FORMAT_A2R10G10B10_USCALED_PACK32 specifies 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.
VK_FORMAT_A2R10G10B10_SSCALED_PACK32 specifies 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.
VK_FORMAT_A2R10G10B10_UINT_PACK32 specifies 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.
VK_FORMAT_A2R10G10B10_SINT_PACK32 specifies 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.
VK_FORMAT_A2B10G10R10_UNORM_PACK32 specifies 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.
VK_FORMAT_A2B10G10R10_SNORM_PACK32 specifies 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.
VK_FORMAT_A2B10G10R10_USCALED_PACK32 specifies 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.
VK_FORMAT_A2B10G10R10_SSCALED_PACK32 specifies 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.
VK_FORMAT_A2B10G10R10_UINT_PACK32 specifies 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.
VK_FORMAT_A2B10G10R10_SINT_PACK32 specifies 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.
VK_FORMAT_R16_UNORM specifies a one-component, 16-bit unsigned normalized format that has a single 16-bit R component.
VK_FORMAT_R16_SNORM specifies a one-component, 16-bit signed normalized format that has a single 16-bit R component.
VK_FORMAT_R16_USCALED specifies a one-component, 16-bit unsigned scaled integer format that has a single 16-bit R component.
VK_FORMAT_R16_SSCALED specifies a one-component, 16-bit signed scaled integer format that has a single 16-bit R component.
VK_FORMAT_R16_UINT specifies a one-component, 16-bit unsigned integer format that has a single 16-bit R component.
VK_FORMAT_R16_SINT specifies a one-component, 16-bit signed integer format that has a single 16-bit R component.
VK_FORMAT_R16_SFLOAT specifies a one-component, 16-bit signed floating-point format that has a single 16-bit R component.
VK_FORMAT_R16G16_UNORM specifies 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.
VK_FORMAT_R16G16_SNORM specifies 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.
VK_FORMAT_R16G16_USCALED specifies 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.
VK_FORMAT_R16G16_SSCALED specifies 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.
VK_FORMAT_R16G16_UINT specifies 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.
VK_FORMAT_R16G16_SINT specifies 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.
VK_FORMAT_R16G16_SFLOAT specifies 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.
VK_FORMAT_R16G16B16_UNORM specifies 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.
VK_FORMAT_R16G16B16_SNORM specifies 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.
VK_FORMAT_R16G16B16_USCALED specifies 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.
VK_FORMAT_R16G16B16_SSCALED specifies 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.
VK_FORMAT_R16G16B16_UINT specifies 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.
VK_FORMAT_R16G16B16_SINT specifies 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.
VK_FORMAT_R16G16B16_SFLOAT specifies 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.
VK_FORMAT_R16G16B16A16_UNORM specifies 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.
VK_FORMAT_R16G16B16A16_SNORM specifies 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.
VK_FORMAT_R16G16B16A16_USCALED specifies 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.
VK_FORMAT_R16G16B16A16_SSCALED specifies 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.
VK_FORMAT_R16G16B16A16_UINT specifies 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.
VK_FORMAT_R16G16B16A16_SINT specifies 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.
VK_FORMAT_R16G16B16A16_SFLOAT specifies 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.
VK_FORMAT_R32_UINT specifies a one-component, 32-bit unsigned integer format that has a single 32-bit R component.
VK_FORMAT_R32_SINT specifies a one-component, 32-bit signed integer format that has a single 32-bit R component.
VK_FORMAT_R32_SFLOAT specifies a one-component, 32-bit signed floating-point format that has a single 32-bit R component.
VK_FORMAT_R32G32_UINT specifies 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.
VK_FORMAT_R32G32_SINT specifies 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.
VK_FORMAT_R32G32_SFLOAT specifies 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.
VK_FORMAT_R32G32B32_UINT specifies 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.
VK_FORMAT_R32G32B32_SINT specifies 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.
VK_FORMAT_R32G32B32_SFLOAT specifies 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.
VK_FORMAT_R32G32B32A32_UINT specifies 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.
VK_FORMAT_R32G32B32A32_SINT specifies 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.
VK_FORMAT_R32G32B32A32_SFLOAT specifies 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.
VK_FORMAT_R64_UINT specifies a one-component, 64-bit unsigned integer format that has a single 64-bit R component.
VK_FORMAT_R64_SINT specifies a one-component, 64-bit signed integer format that has a single 64-bit R component.
VK_FORMAT_R64_SFLOAT specifies a one-component, 64-bit signed floating-point format that has a single 64-bit R component.
VK_FORMAT_R64G64_UINT specifies 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.
VK_FORMAT_R64G64_SINT specifies 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.
VK_FORMAT_R64G64_SFLOAT specifies 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.
VK_FORMAT_R64G64B64_UINT specifies 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.
VK_FORMAT_R64G64B64_SINT specifies 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.
VK_FORMAT_R64G64B64_SFLOAT specifies 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.
VK_FORMAT_R64G64B64A64_UINT specifies 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.
VK_FORMAT_R64G64B64A64_SINT specifies 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.
VK_FORMAT_R64G64B64A64_SFLOAT specifies 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.
VK_FORMAT_B10G11R11_UFLOAT_PACK32 specifies 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 Unsigned 10-Bit Floating-Point Numbers and Unsigned 11-Bit Floating-Point Numbers.
VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 specifies 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.
VK_FORMAT_D16_UNORM specifies a one-component, 16-bit unsigned normalized format that has a single 16-bit depth component.
VK_FORMAT_X8_D24_UNORM_PACK32 specifies a two-component, 32-bit format that has 24 unsigned normalized bits in the depth component and, optionally:, 8 bits that are unused.
VK_FORMAT_D32_SFLOAT specifies a one-component, 32-bit signed floating-point format that has 32-bits in the depth component.
VK_FORMAT_S8_UINT specifies a one-component, 8-bit unsigned integer format that has 8-bits in the stencil component.
VK_FORMAT_D16_UNORM_S8_UINT specifies 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.
VK_FORMAT_D24_UNORM_S8_UINT specifies 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.
VK_FORMAT_D32_SFLOAT_S8_UINT specifies 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.
VK_FORMAT_BC1_RGB_UNORM_BLOCK specifies a three-component, block-compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGB texel data. This format has no alpha and is considered opaque.
VK_FORMAT_BC1_RGB_SRGB_BLOCK specifies a three-component, block-compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGB texel data with sRGB nonlinear encoding. This format has no alpha and is considered opaque.
VK_FORMAT_BC1_RGBA_UNORM_BLOCK specifies a four-component, block-compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGB texel data, and provides 1 bit of alpha.
VK_FORMAT_BC1_RGBA_SRGB_BLOCK specifies a four-component, block-compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGB texel data with sRGB nonlinear encoding, and provides 1 bit of alpha.
VK_FORMAT_BC2_UNORM_BLOCK specifies a four-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with the first 64 bits encoding alpha values followed by 64 bits encoding RGB values.
VK_FORMAT_BC2_SRGB_BLOCK specifies a four-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with the first 64 bits encoding alpha values followed by 64 bits encoding RGB values with sRGB nonlinear encoding.
VK_FORMAT_BC3_UNORM_BLOCK specifies a four-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with the first 64 bits encoding alpha values followed by 64 bits encoding RGB values.
VK_FORMAT_BC3_SRGB_BLOCK specifies a four-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with the first 64 bits encoding alpha values followed by 64 bits encoding RGB values with sRGB nonlinear encoding.
VK_FORMAT_BC4_UNORM_BLOCK specifies a one-component, block-compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized red texel data.
VK_FORMAT_BC4_SNORM_BLOCK specifies a one-component, block-compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of signed normalized red texel data.
VK_FORMAT_BC5_UNORM_BLOCK specifies a two-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RG texel data with the first 64 bits encoding red values followed by 64 bits encoding green values.
VK_FORMAT_BC5_SNORM_BLOCK specifies a two-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of signed normalized RG texel data with the first 64 bits encoding red values followed by 64 bits encoding green values.
VK_FORMAT_BC6H_UFLOAT_BLOCK specifies a three-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned floating-point RGB texel data.
VK_FORMAT_BC6H_SFLOAT_BLOCK specifies a three-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of signed floating-point RGB texel data.
VK_FORMAT_BC7_UNORM_BLOCK specifies a four-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_BC7_SRGB_BLOCK specifies a four-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK specifies a three-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGB texel data. This format has no alpha and is considered opaque.
VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK specifies a three-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGB texel data with sRGB nonlinear encoding. This format has no alpha and is considered opaque.
VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK specifies a four-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGB texel data, and provides 1 bit of alpha.
VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK specifies a four-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGB texel data with sRGB nonlinear encoding, and provides 1 bit of alpha.
VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK specifies a four-component, ETC2 compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with the first 64 bits encoding alpha values followed by 64 bits encoding RGB values.
VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK specifies a four-component, ETC2 compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with the first 64 bits encoding alpha values followed by 64 bits encoding RGB values with sRGB nonlinear encoding applied.
VK_FORMAT_EAC_R11_UNORM_BLOCK specifies a one-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized red texel data.
VK_FORMAT_EAC_R11_SNORM_BLOCK specifies a one-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of signed normalized red texel data.
VK_FORMAT_EAC_R11G11_UNORM_BLOCK specifies a two-component, ETC2 compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RG texel data with the first 64 bits encoding red values followed by 64 bits encoding green values.
VK_FORMAT_EAC_R11G11_SNORM_BLOCK specifies a two-component, ETC2 compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of signed normalized RG texel data with the first 64 bits encoding red values followed by 64 bits encoding green values.
VK_FORMAT_ASTC_4x4_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_ASTC_4x4_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of signed floating-point RGBA texel data.
VK_FORMAT_ASTC_5x4_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 5×4 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_ASTC_5x4_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 5×4 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 5×4 rectangle of signed floating-point RGBA texel data.
VK_FORMAT_ASTC_5x5_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 5×5 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_ASTC_5x5_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 5×5 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 5×5 rectangle of signed floating-point RGBA texel data.
VK_FORMAT_ASTC_6x5_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 6×5 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_ASTC_6x5_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 6×5 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 6×5 rectangle of signed floating-point RGBA texel data.
VK_FORMAT_ASTC_6x6_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 6×6 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_ASTC_6x6_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 6×6 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 6×6 rectangle of signed floating-point RGBA texel data.
VK_FORMAT_ASTC_8x5_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8×5 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_ASTC_8x5_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8×5 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 8×5 rectangle of signed floating-point RGBA texel data.
VK_FORMAT_ASTC_8x6_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8×6 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_ASTC_8x6_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8×6 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 8×6 rectangle of signed floating-point RGBA texel data.
VK_FORMAT_ASTC_8x8_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8×8 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_ASTC_8x8_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8×8 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 8×8 rectangle of signed floating-point RGBA texel data.
VK_FORMAT_ASTC_10x5_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×5 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_ASTC_10x5_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×5 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×5 rectangle of signed floating-point RGBA texel data.
VK_FORMAT_ASTC_10x6_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×6 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_ASTC_10x6_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×6 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×6 rectangle of signed floating-point RGBA texel data.
VK_FORMAT_ASTC_10x8_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×8 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_ASTC_10x8_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×8 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×8 rectangle of signed floating-point RGBA texel data.
VK_FORMAT_ASTC_10x10_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×10 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_ASTC_10x10_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×10 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×10 rectangle of signed floating-point RGBA texel data.
VK_FORMAT_ASTC_12x10_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 12×10 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_ASTC_12x10_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 12×10 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 12×10 rectangle of signed floating-point RGBA texel data.
VK_FORMAT_ASTC_12x12_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 12×12 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_ASTC_12x12_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 12×12 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 12×12 rectangle of signed floating-point RGBA texel data.
VK_FORMAT_G8B8G8R8_422_UNORM specifies a four-component, 32-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has an 8-bit G component for the even i coordinate in byte 0, an 8-bit B component in byte 1, an 8-bit G component for the odd i coordinate in byte 2, and an 8-bit R component in byte 3. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.
VK_FORMAT_B8G8R8G8_422_UNORM specifies a four-component, 32-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has an 8-bit B component in byte 0, an 8-bit G component for the even i coordinate in byte 1, an 8-bit R component in byte 2, and an 8-bit G component for the odd i coordinate in byte 3. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.
VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM specifies an unsigned normalized multi-planar format that has an 8-bit G component in plane 0, an 8-bit B component in plane 1, and an 8-bit R component in plane 2. The horizontal and vertical dimensions of the R and B planes are halved relative to the image dimensions, and each R and B component is shared with the G components for which \(\lfloor i_G \times 0.5 \rfloor = i_B = i_R\) and \(\lfloor j_G \times 0.5 \rfloor = j_B = j_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width and height that is a multiple of two.
VK_FORMAT_G8_B8R8_2PLANE_420_UNORM specifies an unsigned normalized multi-planar format that has an 8-bit G component in plane 0, and a two-component, 16-bit BR plane 1 consisting of an 8-bit B component in byte 0 and an 8-bit R component in byte 1. The horizontal and vertical dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\lfloor i_G \times 0.5 \rfloor = i_B = i_R\) and \(\lfloor j_G \times 0.5 \rfloor = j_B = j_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, and VK_IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width and height that is a multiple of two.
VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM specifies an unsigned normalized multi-planar format that has an 8-bit G component in plane 0, an 8-bit B component in plane 1, and an 8-bit R component in plane 2. The horizontal dimension of the R and B plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\lfloor i_G \times 0.5 \rfloor = i_B = i_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width that is a multiple of two.
VK_FORMAT_G8_B8R8_2PLANE_422_UNORM specifies an unsigned normalized multi-planar format that has an 8-bit G component in plane 0, and a two-component, 16-bit BR plane 1 consisting of an 8-bit B component in byte 0 and an 8-bit R component in byte 1. The horizontal dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\lfloor i_G \times 0.5 \rfloor = i_B = i_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, and VK_IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width that is a multiple of two.
VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM specifies an unsigned normalized multi-planar format that has an 8-bit G component in plane 0, an 8-bit B component in plane 1, and an 8-bit R component in plane 2. Each plane has the same dimensions and each R, G and B component contributes to a single texel. The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane.
VK_FORMAT_R10X6_UNORM_PACK16 specifies a one-component, 16-bit unsigned normalized format that has a single 10-bit R component in the top 10 bits of a 16-bit word, with the bottom 6 bits set to 0.
VK_FORMAT_R10X6G10X6_UNORM_2PACK16 specifies a two-component, 32-bit unsigned normalized format that has a 10-bit R component in the top 10 bits of the word in bytes 0..1, and a 10-bit G component in the top 10 bits of the word in bytes 2..3, with the bottom 6 bits of each word set to 0.
VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 specifies a four-component, 64-bit unsigned normalized format that has a 10-bit R component in the top 10 bits of the word in bytes 0..1, a 10-bit G component in the top 10 bits of the word in bytes 2..3, a 10-bit B component in the top 10 bits of the word in bytes 4..5, and a 10-bit A component in the top 10 bits of the word in bytes 6..7, with the bottom 6 bits of each word set to 0.
VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 10-bit G component for the even i coordinate in the top 10 bits of the word in bytes 0..1, a 10-bit B component in the top 10 bits of the word in bytes 2..3, a 10-bit G component for the odd i coordinate in the top 10 bits of the word in bytes 4..5, and a 10-bit R component in the top 10 bits of the word in bytes 6..7, with the bottom 6 bits of each word set to 0. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.
VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 10-bit B component in the top 10 bits of the word in bytes 0..1, a 10-bit G component for the even i coordinate in the top 10 bits of the word in bytes 2..3, a 10-bit R component in the top 10 bits of the word in bytes 4..5, and a 10-bit G component for the odd i coordinate in the top 10 bits of the word in bytes 6..7, with the bottom 6 bits of each word set to 0. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.
VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 10-bit G component in the top 10 bits of each 16-bit word of plane 0, a 10-bit B component in the top 10 bits of each 16-bit word of plane 1, and a 10-bit R component in the top 10 bits of each 16-bit word of plane 2, with the bottom 6 bits of each word set to 0. The horizontal and vertical dimensions of the R and B planes are halved relative to the image dimensions, and each R and B component is shared with the G components for which \(\lfloor i_G \times 0.5 \rfloor = i_B = i_R\) and \(\lfloor j_G \times 0.5 \rfloor = j_B = j_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width and height that is a multiple of two.
VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 10-bit G component in the top 10 bits of each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 10-bit B component in the top 10 bits of the word in bytes 0..1, and a 10-bit R component in the top 10 bits of the word in bytes 2..3, the bottom 6 bits of each word set to 0. The horizontal and vertical dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\lfloor i_G \times 0.5 \rfloor = i_B = i_R\) and \(\lfloor j_G \times 0.5 \rfloor = j_B = j_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, and VK_IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width and height that is a multiple of two.
VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 10-bit G component in the top 10 bits of each 16-bit word of plane 0, a 10-bit B component in the top 10 bits of each 16-bit word of plane 1, and a 10-bit R component in the top 10 bits of each 16-bit word of plane 2, with the bottom 6 bits of each word set to 0. The horizontal dimension of the R and B plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\lfloor i_G \times 0.5 \rfloor = i_B = i_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width that is a multiple of two.
VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 10-bit G component in the top 10 bits of each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 10-bit B component in the top 10 bits of the word in bytes 0..1, and a 10-bit R component in the top 10 bits of the word in bytes 2..3, the bottom 6 bits of each word set to 0. The horizontal dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\lfloor i_G \times 0.5 \rfloor = i_B = i_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, and VK_IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width that is a multiple of two.
VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 10-bit G component in the top 10 bits of each 16-bit word of plane 0, a 10-bit B component in the top 10 bits of each 16-bit word of plane 1, and a 10-bit R component in the top 10 bits of each 16-bit word of plane 2, with the bottom 6 bits of each word set to 0. Each plane has the same dimensions and each R, G and B component contributes to a single texel. The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane.
VK_FORMAT_R12X4_UNORM_PACK16 specifies a one-component, 16-bit unsigned normalized format that has a single 12-bit R component in the top 12 bits of a 16-bit word, with the bottom 4 bits set to 0.
VK_FORMAT_R12X4G12X4_UNORM_2PACK16 specifies a two-component, 32-bit unsigned normalized format that has a 12-bit R component in the top 12 bits of the word in bytes 0..1, and a 12-bit G component in the top 12 bits of the word in bytes 2..3, with the bottom 4 bits of each word set to 0.
VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 specifies a four-component, 64-bit unsigned normalized format that has a 12-bit R component in the top 12 bits of the word in bytes 0..1, a 12-bit G component in the top 12 bits of the word in bytes 2..3, a 12-bit B component in the top 12 bits of the word in bytes 4..5, and a 12-bit A component in the top 12 bits of the word in bytes 6..7, with the bottom 4 bits of each word set to 0.
VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 12-bit G component for the even i coordinate in the top 12 bits of the word in bytes 0..1, a 12-bit B component in the top 12 bits of the word in bytes 2..3, a 12-bit G component for the odd i coordinate in the top 12 bits of the word in bytes 4..5, and a 12-bit R component in the top 12 bits of the word in bytes 6..7, with the bottom 4 bits of each word set to 0. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.
VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 12-bit B component in the top 12 bits of the word in bytes 0..1, a 12-bit G component for the even i coordinate in the top 12 bits of the word in bytes 2..3, a 12-bit R component in the top 12 bits of the word in bytes 4..5, and a 12-bit G component for the odd i coordinate in the top 12 bits of the word in bytes 6..7, with the bottom 4 bits of each word set to 0. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.
VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 12-bit G component in the top 12 bits of each 16-bit word of plane 0, a 12-bit B component in the top 12 bits of each 16-bit word of plane 1, and a 12-bit R component in the top 12 bits of each 16-bit word of plane 2, with the bottom 4 bits of each word set to 0. The horizontal and vertical dimensions of the R and B planes are halved relative to the image dimensions, and each R and B component is shared with the G components for which \(\lfloor i_G \times 0.5 \rfloor = i_B = i_R\) and \(\lfloor j_G \times 0.5 \rfloor = j_B = j_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width and height that is a multiple of two.
VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 12-bit G component in the top 12 bits of each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 12-bit B component in the top 12 bits of the word in bytes 0..1, and a 12-bit R component in the top 12 bits of the word in bytes 2..3, the bottom 4 bits of each word set to 0. The horizontal and vertical dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\lfloor i_G \times 0.5 \rfloor = i_B = i_R\) and \(\lfloor j_G \times 0.5 \rfloor = j_B = j_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, and VK_IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width and height that is a multiple of two.
VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 12-bit G component in the top 12 bits of each 16-bit word of plane 0, a 12-bit B component in the top 12 bits of each 16-bit word of plane 1, and a 12-bit R component in the top 12 bits of each 16-bit word of plane 2, with the bottom 4 bits of each word set to 0. The horizontal dimension of the R and B plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\lfloor i_G \times 0.5 \rfloor = i_B = i_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width that is a multiple of two.
VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 12-bit G component in the top 12 bits of each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 12-bit B component in the top 12 bits of the word in bytes 0..1, and a 12-bit R component in the top 12 bits of the word in bytes 2..3, the bottom 4 bits of each word set to 0. The horizontal dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\lfloor i_G \times 0.5 \rfloor = i_B = i_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, and VK_IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width that is a multiple of two.
VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 12-bit G component in the top 12 bits of each 16-bit word of plane 0, a 12-bit B component in the top 12 bits of each 16-bit word of plane 1, and a 12-bit R component in the top 12 bits of each 16-bit word of plane 2, with the bottom 4 bits of each word set to 0. Each plane has the same dimensions and each R, G and B component contributes to a single texel. The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane.
VK_FORMAT_G16B16G16R16_422_UNORM specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 16-bit G component for the even i coordinate in the word in bytes 0..1, a 16-bit B component in the word in bytes 2..3, a 16-bit G component for the odd i coordinate in the word in bytes 4..5, and a 16-bit R component in the word in bytes 6..7. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.
VK_FORMAT_B16G16R16G16_422_UNORM specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 16-bit B component in the word in bytes 0..1, a 16-bit G component for the even i coordinate in the word in bytes 2..3, a 16-bit R component in the word in bytes 4..5, and a 16-bit G component for the odd i coordinate in the word in bytes 6..7. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.
VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM specifies an unsigned normalized multi-planar format that has a 16-bit G component in each 16-bit word of plane 0, a 16-bit B component in each 16-bit word of plane 1, and a 16-bit R component in each 16-bit word of plane 2. The horizontal and vertical dimensions of the R and B planes are halved relative to the image dimensions, and each R and B component is shared with the G components for which \(\lfloor i_G \times 0.5 \rfloor = i_B = i_R\) and \(\lfloor j_G \times 0.5 \rfloor = j_B = j_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width and height that is a multiple of two.
VK_FORMAT_G16_B16R16_2PLANE_420_UNORM specifies an unsigned normalized multi-planar format that has a 16-bit G component in each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 16-bit B component in the word in bytes 0..1, and a 16-bit R component in the word in bytes 2..3. The horizontal and vertical dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\lfloor i_G \times 0.5 \rfloor = i_B = i_R\) and \(\lfloor j_G \times 0.5 \rfloor = j_B = j_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, and VK_IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width and height that is a multiple of two.
VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM specifies an unsigned normalized multi-planar format that has a 16-bit G component in each 16-bit word of plane 0, a 16-bit B component in each 16-bit word of plane 1, and a 16-bit R component in each 16-bit word of plane 2. The horizontal dimension of the R and B plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\lfloor i_G \times 0.5 \rfloor = i_B = i_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width that is a multiple of two.
VK_FORMAT_G16_B16R16_2PLANE_422_UNORM specifies an unsigned normalized multi-planar format that has a 16-bit G component in each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 16-bit B component in the word in bytes 0..1, and a 16-bit R component in the word in bytes 2..3. The horizontal dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\lfloor i_G \times 0.5 \rfloor = i_B = i_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, and VK_IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width that is a multiple of two.
VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM specifies an unsigned normalized multi-planar format that has a 16-bit G component in each 16-bit word of plane 0, a 16-bit B component in each 16-bit word of plane 1, and a 16-bit R component in each 16-bit word of plane 2. Each plane has the same dimensions and each R, G and B component contributes to a single texel. The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane.
VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG specifies a four-component, PVRTC compressed format where each 64-bit compressed texel block encodes an 8×4 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG specifies a four-component, PVRTC compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG specifies a four-component, PVRTC compressed format where each 64-bit compressed texel block encodes an 8×4 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG specifies a four-component, PVRTC compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data.
VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG specifies a four-component, PVRTC compressed format where each 64-bit compressed texel block encodes an 8×4 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG specifies a four-component, PVRTC compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG specifies a four-component, PVRTC compressed format where each 64-bit compressed texel block encodes an 8×4 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.
VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG specifies a four-component, PVRTC compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

37.1.1. Compatible formats of planes of multi-planar formats

Individual planes of multi-planar formats are compatible with single-plane formats if they occupy the same number of bits per texel block. In the following table, individual planes of a multi-planar format are compatible with the format listed against the relevant plane index for that multi-planar format.

Table 47. Plane Format Compatibility Table
Plane	Compatible format for plane	Width relative to the width w of the plane with the largest dimensions	Height relative to the height h of the plane with the largest dimensions
`VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM`
0	`VK_FORMAT_R8_UNORM`	w	h
1	`VK_FORMAT_R8_UNORM`	w/2	h/2
2	`VK_FORMAT_R8_UNORM`	w/2	h/2
`VK_FORMAT_G8_B8R8_2PLANE_420_UNORM`
0	`VK_FORMAT_R8_UNORM`	w	h
1	`VK_FORMAT_R8G8_UNORM`	w/2	h/2
`VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM`
0	`VK_FORMAT_R8_UNORM`	w	h
1	`VK_FORMAT_R8_UNORM`	w/2	h
2	`VK_FORMAT_R8_UNORM`	w/2	h
`VK_FORMAT_G8_B8R8_2PLANE_422_UNORM`
0	`VK_FORMAT_R8_UNORM`	w	h
1	`VK_FORMAT_R8G8_UNORM`	w/2	h
`VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM`
0	`VK_FORMAT_R8_UNORM`	w	h
1	`VK_FORMAT_R8_UNORM`	w	h
2	`VK_FORMAT_R8_UNORM`	w	h
`VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16`
0	`VK_FORMAT_R10X6_UNORM_PACK16`	w	h
1	`VK_FORMAT_R10X6_UNORM_PACK16`	w/2	h/2
2	`VK_FORMAT_R10X6_UNORM_PACK16`	w/2	h/2
`VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16`
0	`VK_FORMAT_R10X6_UNORM_PACK16`	w	h
1	`VK_FORMAT_R10X6G10X6_UNORM_2PACK16`	w/2	h/2
`VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16`
0	`VK_FORMAT_R10X6_UNORM_PACK16`	w	h
1	`VK_FORMAT_R10X6_UNORM_PACK16`	w/2	h
2	`VK_FORMAT_R10X6_UNORM_PACK16`	w/2	h
`VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16`
0	`VK_FORMAT_R10X6_UNORM_PACK16`	w	h
1	`VK_FORMAT_R10X6G10X6_UNORM_2PACK16`	w/2	h
`VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16`
0	`VK_FORMAT_R10X6_UNORM_PACK16`	w	h
1	`VK_FORMAT_R10X6_UNORM_PACK16`	w	h
2	`VK_FORMAT_R10X6_UNORM_PACK16`	w	h
`VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16`
0	`VK_FORMAT_R12X4_UNORM_PACK16`	w	h
1	`VK_FORMAT_R12X4_UNORM_PACK16`	w/2	h/2
2	`VK_FORMAT_R12X4_UNORM_PACK16`	w/2	h/2
`VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16`
0	`VK_FORMAT_R12X4_UNORM_PACK16`	w	h
1	`VK_FORMAT_R12X4G12X4_UNORM_2PACK16`	w/2	h/2
`VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16`
0	`VK_FORMAT_R12X4_UNORM_PACK16`	w	h
1	`VK_FORMAT_R12X4_UNORM_PACK16`	w/2	h
2	`VK_FORMAT_R12X4_UNORM_PACK16`	w/2	h
`VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16`
0	`VK_FORMAT_R12X4_UNORM_PACK16`	w	h
1	`VK_FORMAT_R12X4G12X4_UNORM_2PACK16`	w/2	h
`VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16`
0	`VK_FORMAT_R12X4_UNORM_PACK16`	w	h
1	`VK_FORMAT_R12X4_UNORM_PACK16`	w	h
2	`VK_FORMAT_R12X4_UNORM_PACK16`	w	h
`VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM`
0	`VK_FORMAT_R16_UNORM`	w	h
1	`VK_FORMAT_R16_UNORM`	w/2	h/2
2	`VK_FORMAT_R16_UNORM`	w/2	h/2
`VK_FORMAT_G16_B16R16_2PLANE_420_UNORM`
0	`VK_FORMAT_R16_UNORM`	w	h
1	`VK_FORMAT_R16G16_UNORM`	w/2	h/2
`VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM`
0	`VK_FORMAT_R16_UNORM`	w	h
1	`VK_FORMAT_R16_UNORM`	w/2	h
2	`VK_FORMAT_R16_UNORM`	w/2	h
`VK_FORMAT_G16_B16R16_2PLANE_422_UNORM`
0	`VK_FORMAT_R16_UNORM`	w	h
1	`VK_FORMAT_R16G16_UNORM`	w/2	h
`VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM`
0	`VK_FORMAT_R16_UNORM`	w	h
1	`VK_FORMAT_R16_UNORM`	w	h
2	`VK_FORMAT_R16_UNORM`	w	h

37.1.2. Packed Formats

For the purposes of address alignment when accessing buffer memory containing vertex attribute or texel data, the following formats are considered packed - whole texels or attributes are stored in bitfields of a single 8-, 16-, or 32-bit fundamental data type.

Packed into 8-bit data types:
- VK_FORMAT_R4G4_UNORM_PACK8
Packed into 16-bit data types:
- VK_FORMAT_R4G4B4A4_UNORM_PACK16
- VK_FORMAT_B4G4R4A4_UNORM_PACK16
- VK_FORMAT_R5G6B5_UNORM_PACK16
- VK_FORMAT_B5G6R5_UNORM_PACK16
- VK_FORMAT_R5G5B5A1_UNORM_PACK16
- VK_FORMAT_B5G5R5A1_UNORM_PACK16
- VK_FORMAT_A1R5G5B5_UNORM_PACK16
Packed into 32-bit data types:
- VK_FORMAT_A8B8G8R8_UNORM_PACK32
- VK_FORMAT_A8B8G8R8_SNORM_PACK32
- VK_FORMAT_A8B8G8R8_USCALED_PACK32
- VK_FORMAT_A8B8G8R8_SSCALED_PACK32
- VK_FORMAT_A8B8G8R8_UINT_PACK32
- VK_FORMAT_A8B8G8R8_SINT_PACK32
- VK_FORMAT_A8B8G8R8_SRGB_PACK32
- VK_FORMAT_A2R10G10B10_UNORM_PACK32
- VK_FORMAT_A2R10G10B10_SNORM_PACK32
- VK_FORMAT_A2R10G10B10_USCALED_PACK32
- VK_FORMAT_A2R10G10B10_SSCALED_PACK32
- VK_FORMAT_A2R10G10B10_UINT_PACK32
- VK_FORMAT_A2R10G10B10_SINT_PACK32
- VK_FORMAT_A2B10G10R10_UNORM_PACK32
- VK_FORMAT_A2B10G10R10_SNORM_PACK32
- VK_FORMAT_A2B10G10R10_USCALED_PACK32
- VK_FORMAT_A2B10G10R10_SSCALED_PACK32
- VK_FORMAT_A2B10G10R10_UINT_PACK32
- VK_FORMAT_A2B10G10R10_SINT_PACK32
- VK_FORMAT_B10G11R11_UFLOAT_PACK32
- VK_FORMAT_E5B9G9R9_UFLOAT_PACK32
- VK_FORMAT_X8_D24_UNORM_PACK32

37.1.3. Identification of Formats

A “format” is represented by a single enum value. The name of a format is usually built up by using the following pattern:

    VK_FORMAT_{component-format|compression-scheme}_{numeric-format}

The component-format indicates either the size of the R, G, B, and A components (if they are present) in the case of a color format, or the size of the depth (D) and stencil (S) components (if they are present) in the case of a depth/stencil format (see below). An X indicates a component that is unused, but may be present for padding.

Table 48. Interpretation of Numeric Format
Numeric format	SPIR-V Sampled Type	Description
`UNORM`	OpTypeFloat	The components are unsigned normalized values in the range [0,1]
`SNORM`	OpTypeFloat	The components are signed normalized values in the range [-1,1]
`USCALED`	OpTypeFloat	The components are unsigned integer values that get converted to floating-point in the range [0,2ⁿ-1]
`SSCALED`	OpTypeFloat	The components are signed integer values that get converted to floating-point in the range [-2^n-1,2^n-1-1]
`UINT`	OpTypeInt	The components are unsigned integer values in the range [0,2ⁿ-1]
`SINT`	OpTypeInt	The components are signed integer values in the range [-2^n-1,2^n-1-1]
`UFLOAT`	OpTypeFloat	The components are unsigned floating-point numbers (used by packed, shared exponent, and some compressed formats)
`SFLOAT`	OpTypeFloat	The components are signed floating-point numbers
`SRGB`	OpTypeFloat	The R, G, and B components are unsigned normalized values that represent values using sRGB nonlinear encoding, while the A component (if one exists) is a regular unsigned normalized value

The suffix _PACKnn indicates that the format is packed into an underlying type with nn bits. The suffix _mPACKnn is a short-hand that indicates that the format has several components (which may or may not be stored in separate planes) that are each packed into an underlying type with nn bits.

The suffix _BLOCK indicates that the format is a block-compressed format, with the representation of multiple pixels encoded interdependently within a region.

Table 49. Interpretation of Compression Scheme
Compression scheme	Description
`BC`	Block Compression. See Block-Compressed Image Formats.
`ETC2`	Ericsson Texture Compression. See ETC Compressed Image Formats.
`EAC`	ETC2 Alpha Compression. See ETC Compressed Image Formats.
`ASTC`	Adaptive Scalable Texture Compression (LDR Profile). See ASTC Compressed Image Formats.

For multi-planar images, the components in separate planes are separated by underscores, and the number of planes is indicated by the addition of a _2PLANE or _3PLANE suffix. Similarly, the separate aspects of depth-stencil formats are separated by underscores, although these are not considered separate planes. Formats are suffixed by _422 to indicate that planes other than the first are reduced in size by a factor of two horizontally or that the R and B values appear at half the horizontal frequency of the G values, _420 to indicate that planes other than the first are reduced in size by a factor of two both horizontally and vertically, and _444 for consistency to indicate that all three planes of a three-planar image are the same size.

Note

No common format has a single plane containing both R and B channels but does not store these channels at reduced horizontal resolution.

37.1.4. Representation and Texel Block Size

Color formats must be represented in memory in exactly the form indicated by the format’s name. This means that promoting one format to another with more bits per component and/or additional components must not occur for color formats. Depth/stencil formats have more relaxed requirements as discussed below.

Each format has a texel block size, the number of bytes used to store one texel block (a single addressable element of an uncompressed image, or a single compressed block of a compressed image). The texel block size for each format is shown in the Compatible formats table.

The representation of non-packed formats is that the first component specified in the name of the format is in the lowest memory addresses and the last component specified is in the highest memory addresses. See Byte mappings for non-packed/compressed color formats. The in-memory ordering of bytes within a component is determined by the host endianness.

Table 50. Byte mappings for non-packed/compressed color formats
0	1	2	3	4	6	8	12	← Byte
R	*`VK_FORMAT_R8_`**
R	G	*`VK_FORMAT_R8G8_`**
R	G	B	*`VK_FORMAT_R8G8B8_`**
B	G	R	*`VK_FORMAT_B8G8R8_`**
R	G	B	A	*`VK_FORMAT_R8G8B8A8_`**
B	G	R	A	*`VK_FORMAT_B8G8R8A8_`**
G₀	B	G₁	R	`VK_FORMAT_G8B8G8R8_422_UNORM`
B	G₀	R	G₁	`VK_FORMAT_B8G8R8G8_422_UNORM`
R		*`VK_FORMAT_R16_`**
R		G		*`VK_FORMAT_R16G16_`**
R		G		B	*`VK_FORMAT_R16G16B16_`**
R		G		B	A	*`VK_FORMAT_R16G16B16A16_`**
G₀		B		G₁	R	`VK_FORMAT_G10X6B10X6G10X6R10X6_4PACK16_422_UNORM` `VK_FORMAT_G12X4B12X4G12X4R12X4_4PACK16_422_UNORM` `VK_FORMAT_G16B16G16R16_UNORM`
B		G₀		R	G₁	`VK_FORMAT_B10X6G10X6R10X6G10X6_4PACK16_422_UNORM` `VK_FORMAT_B12X4G12X4R12X4G12X4_4PACK16_422_UNORM` `VK_FORMAT_B16G16R16G16_422_UNORM`
R				*`VK_FORMAT_R32_`**
R				G		*`VK_FORMAT_R32G32_`**
R				G		B	*`VK_FORMAT_R32G32B32_`**
R				G		B	A	*`VK_FORMAT_R32G32B32A32_`**
R						*`VK_FORMAT_R64_`**
R						G		*`VK_FORMAT_R64G64_`**
*`VK_FORMAT_R64G64B64_` as `VK_FORMAT_R64G64_` but with B in bytes 16-23*
*`VK_FORMAT_R64G64B64A64_` as `VK_FORMAT_R64G64B64_` but with A in bytes 24-31*

Packed formats store multiple components within one underlying type. The bit representation is that the first component specified in the name of the format is in the most-significant bits and the last component specified is in the least-significant bits of the underlying type. The in-memory ordering of bytes comprising the underlying type is determined by the host endianness.

Table 51. Bit mappings for packed 8-bit formats
Bit
₇	₆	₅	₄	₃	₂	₁	₀
`VK_FORMAT_R4G4_UNORM_PACK8`
R				G
₃	₂	₁	₀	₃	₂	₁	₀

Table 52. Bit mappings for packed 16-bit formats
Bit
₁₅	₁₄	₁₃	₁₂	₁₁	₁₀	₉	₈	₇	₆	₅	₄	₃	₂	₁	₀
`VK_FORMAT_R4G4B4A4_UNORM_PACK16`
R				G				B				A
₃	₂	₁	₀	₃	₂	₁	₀	₃	₂	₁	₀	₃	₂	₁	₀
`VK_FORMAT_B4G4R4A4_UNORM_PACK16`
B				G				R				A
₃	₂	₁	₀	₃	₂	₁	₀	₃	₂	₁	₀	₃	₂	₁	₀
`VK_FORMAT_R5G6B5_UNORM_PACK16`
R					G						B
₄	₃	₂	₁	₀	₅	₄	₃	₂	₁	₀	₄	₃	₂	₁	₀
`VK_FORMAT_B5G6R5_UNORM_PACK16`
B					G						R
₄	₃	₂	₁	₀	₅	₄	₃	₂	₁	₀	₄	₃	₂	₁	₀
`VK_FORMAT_R5G5B5A1_UNORM_PACK16`
R					G					B					A
₄	₃	₂	₁	₀	₄	₃	₂	₁	₀	₄	₃	₂	₁	₀	₀
`VK_FORMAT_B5G5R5A1_UNORM_PACK16`
B					G					R					A
₄	₃	₂	₁	₀	₄	₃	₂	₁	₀	₄	₃	₂	₁	₀	₀
`VK_FORMAT_A1R5G5B5_UNORM_PACK16`
A	R					G					B
₀	₄	₃	₂	₁	₀	₄	₃	₂	₁	₀	₄	₃	₂	₁	₀
`VK_FORMAT_R10X6_UNORM_PACK16`
R										X
₉	₈	₇	₆	₅	₄	₃	₂	₁	₀	₅	₄	₃	₂	₁	₀
`VK_FORMAT_R12X4_UNORM_PACK16`
R												X
₁₁	₁₀	₉	₈	₇	₆	₅	₄	₃	₂	₁	₀	₃	₂	₁	₀

Table 53. Bit mappings for packed 32-bit formats
Bit
₃₁	₃₀	₂₉	₂₈	₂₇	₂₆	₂₅	₂₄	₂₃	₂₂	₂₁	₂₀	₁₉	₁₈	₁₇	₁₆	₁₅	₁₄	₁₃	₁₂	₁₁	₁₀	₉	₈	₇	₆	₅	₄	₃	₂	₁	₀
`VK_FORMAT_A8B8G8R8_*_PACK32`
A								B								G								R
₇	₆	₅	₄	₃	₂	₁	₀	₇	₆	₅	₄	₃	₂	₁	₀	₇	₆	₅	₄	₃	₂	₁	₀	₇	₆	₅	₄	₃	₂	₁	₀
`VK_FORMAT_A2R10G10B10_*_PACK32`
A		R										G										B
₁	₀	₉	₈	₇	₆	₅	₄	₃	₂	₁	₀	₉	₈	₇	₆	₅	₄	₃	₂	₁	₀	₉	₈	₇	₆	₅	₄	₃	₂	₁	₀
`VK_FORMAT_A2B10G10R10_*_PACK32`
A		B										G										R
₁	₀	₉	₈	₇	₆	₅	₄	₃	₂	₁	₀	₉	₈	₇	₆	₅	₄	₃	₂	₁	₀	₉	₈	₇	₆	₅	₄	₃	₂	₁	₀
`VK_FORMAT_B10G11R11_UFLOAT_PACK32`
B										G											R
₉	₈	₇	₆	₅	₄	₃	₂	₁	₀	₁₀	₉	₈	₇	₆	₅	₄	₃	₂	₁	₀	₁₀	₉	₈	₇	₆	₅	₄	₃	₂	₁	₀
`VK_FORMAT_E5B9G9R9_UFLOAT_PACK32`
E					B									G									R
₄	₃	₂	₁	₀	₈	₇	₆	₅	₄	₃	₂	₁	₀	₈	₇	₆	₅	₄	₃	₂	₁	₀	₈	₇	₆	₅	₄	₃	₂	₁	₀
`VK_FORMAT_X8_D24_UNORM_PACK32`
X								D
₇	₆	₅	₄	₃	₂	₁	₀	₂₃	₂₂	₂₁	₂₀	₁₉	₁₈	₁₇	₁₆	₁₅	₁₄	₁₃	₁₂	₁₁	₁₀	₉	₈	₇	₆	₅	₄	₃	₂	₁	₀

37.1.5. Depth/Stencil Formats

Depth/stencil formats are considered opaque and need not be stored in the exact number of bits per texel or component ordering indicated by the format enum. However, implementations must not substitute a different depth or stencil precision than that described in the format (e.g. D16 must not be implemented as D24 or D32).

37.1.6. Format Compatibility Classes

Uncompressed color formats are compatible with each other if they occupy the same number of bits per texel block. Compressed color formats are compatible with each other if the only difference between them is the numerical type of the uncompressed pixels (e.g. signed vs. unsigned, or SRGB vs. UNORM encoding). Each depth/stencil format is only compatible with itself. In the following table, all the formats in the same row are compatible.

Table 54. Compatible Formats
Class, Texel Block Size, # Texels/Block	Formats
8-bit Block size 1 byte 1 texel/block	`VK_FORMAT_R4G4_UNORM_PACK8`, `VK_FORMAT_R8_UNORM`, `VK_FORMAT_R8_SNORM`, `VK_FORMAT_R8_USCALED`, `VK_FORMAT_R8_SSCALED`, `VK_FORMAT_R8_UINT`, `VK_FORMAT_R8_SINT`, `VK_FORMAT_R8_SRGB`
16-bit Block size 2 bytes 1 texel/block	`VK_FORMAT_R4G4B4A4_UNORM_PACK16`, `VK_FORMAT_B4G4R4A4_UNORM_PACK16`, `VK_FORMAT_R5G6B5_UNORM_PACK16`, `VK_FORMAT_B5G6R5_UNORM_PACK16`, `VK_FORMAT_R5G5B5A1_UNORM_PACK16`, `VK_FORMAT_B5G5R5A1_UNORM_PACK16`, `VK_FORMAT_A1R5G5B5_UNORM_PACK16`, `VK_FORMAT_R8G8_UNORM`, `VK_FORMAT_R8G8_SNORM`, `VK_FORMAT_R8G8_USCALED`, `VK_FORMAT_R8G8_SSCALED`, `VK_FORMAT_R8G8_UINT`, `VK_FORMAT_R8G8_SINT`, `VK_FORMAT_R8G8_SRGB`, `VK_FORMAT_R16_UNORM`, `VK_FORMAT_R16_SNORM`, `VK_FORMAT_R16_USCALED`, `VK_FORMAT_R16_SSCALED`, `VK_FORMAT_R16_UINT`, `VK_FORMAT_R16_SINT`, `VK_FORMAT_R16_SFLOAT`, `VK_FORMAT_R10X6_UNORM_PACK16`, `VK_FORMAT_R12X4_UNORM_PACK16`
24-bit Block size 3 bytes 1 texel/block	`VK_FORMAT_R8G8B8_UNORM`, `VK_FORMAT_R8G8B8_SNORM`, `VK_FORMAT_R8G8B8_USCALED`, `VK_FORMAT_R8G8B8_SSCALED`, `VK_FORMAT_R8G8B8_UINT`, `VK_FORMAT_R8G8B8_SINT`, `VK_FORMAT_R8G8B8_SRGB`, `VK_FORMAT_B8G8R8_UNORM`, `VK_FORMAT_B8G8R8_SNORM`, `VK_FORMAT_B8G8R8_USCALED`, `VK_FORMAT_B8G8R8_SSCALED`, `VK_FORMAT_B8G8R8_UINT`, `VK_FORMAT_B8G8R8_SINT`, `VK_FORMAT_B8G8R8_SRGB`
32-bit Block size 4 bytes 1 texel/block	`VK_FORMAT_R8G8B8A8_UNORM`, `VK_FORMAT_R8G8B8A8_SNORM`, `VK_FORMAT_R8G8B8A8_USCALED`, `VK_FORMAT_R8G8B8A8_SSCALED`, `VK_FORMAT_R8G8B8A8_UINT`, `VK_FORMAT_R8G8B8A8_SINT`, `VK_FORMAT_R8G8B8A8_SRGB`, `VK_FORMAT_B8G8R8A8_UNORM`, `VK_FORMAT_B8G8R8A8_SNORM`, `VK_FORMAT_B8G8R8A8_USCALED`, `VK_FORMAT_B8G8R8A8_SSCALED`, `VK_FORMAT_B8G8R8A8_UINT`, `VK_FORMAT_B8G8R8A8_SINT`, `VK_FORMAT_B8G8R8A8_SRGB`, `VK_FORMAT_A8B8G8R8_UNORM_PACK32`, `VK_FORMAT_A8B8G8R8_SNORM_PACK32`, `VK_FORMAT_A8B8G8R8_USCALED_PACK32`, `VK_FORMAT_A8B8G8R8_SSCALED_PACK32`, `VK_FORMAT_A8B8G8R8_UINT_PACK32`, `VK_FORMAT_A8B8G8R8_SINT_PACK32`, `VK_FORMAT_A8B8G8R8_SRGB_PACK32`, `VK_FORMAT_A2R10G10B10_UNORM_PACK32`, `VK_FORMAT_A2R10G10B10_SNORM_PACK32`, `VK_FORMAT_A2R10G10B10_USCALED_PACK32`, `VK_FORMAT_A2R10G10B10_SSCALED_PACK32`, `VK_FORMAT_A2R10G10B10_UINT_PACK32`, `VK_FORMAT_A2R10G10B10_SINT_PACK32`, `VK_FORMAT_A2B10G10R10_UNORM_PACK32`, `VK_FORMAT_A2B10G10R10_SNORM_PACK32`, `VK_FORMAT_A2B10G10R10_USCALED_PACK32`, `VK_FORMAT_A2B10G10R10_SSCALED_PACK32`, `VK_FORMAT_A2B10G10R10_UINT_PACK32`, `VK_FORMAT_A2B10G10R10_SINT_PACK32`, `VK_FORMAT_R16G16_UNORM`, `VK_FORMAT_R16G16_SNORM`, `VK_FORMAT_R16G16_USCALED`, `VK_FORMAT_R16G16_SSCALED`, `VK_FORMAT_R16G16_UINT`, `VK_FORMAT_R16G16_SINT`, `VK_FORMAT_R16G16_SFLOAT`, `VK_FORMAT_R32_UINT`, `VK_FORMAT_R32_SINT`, `VK_FORMAT_R32_SFLOAT`, `VK_FORMAT_B10G11R11_UFLOAT_PACK32`, `VK_FORMAT_E5B9G9R9_UFLOAT_PACK32`, `VK_FORMAT_R10X6G10X6_UNORM_2PACK16`, `VK_FORMAT_R12X4G12X4_UNORM_2PACK16`
32-bit G8B8G8R8 Block size 4 bytes 1 texel/block	`VK_FORMAT_G8B8G8R8_422_UNORM`
32-bit B8G8R8G8 Block size 4 bytes 1 texel/block	`VK_FORMAT_B8G8R8G8_422_UNORM`
48-bit Block size 6 bytes 1 texel/block	`VK_FORMAT_R16G16B16_UNORM`, `VK_FORMAT_R16G16B16_SNORM`, `VK_FORMAT_R16G16B16_USCALED`, `VK_FORMAT_R16G16B16_SSCALED`, `VK_FORMAT_R16G16B16_UINT`, `VK_FORMAT_R16G16B16_SINT`, `VK_FORMAT_R16G16B16_SFLOAT`
64-bit Block size 8 bytes 1 texel/block	`VK_FORMAT_R16G16B16A16_UNORM`, `VK_FORMAT_R16G16B16A16_SNORM`, `VK_FORMAT_R16G16B16A16_USCALED`, `VK_FORMAT_R16G16B16A16_SSCALED`, `VK_FORMAT_R16G16B16A16_UINT`, `VK_FORMAT_R16G16B16A16_SINT`, `VK_FORMAT_R16G16B16A16_SFLOAT`, `VK_FORMAT_R32G32_UINT`, `VK_FORMAT_R32G32_SINT`, `VK_FORMAT_R32G32_SFLOAT`, `VK_FORMAT_R64_UINT`, `VK_FORMAT_R64_SINT`, `VK_FORMAT_R64_SFLOAT`
64-bit R10G10B10A10 Block size 8 bytes 1 texel/block	`VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16`
64-bit G10B10G10R10 Block size 8 bytes 1 texel/block	`VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16`
64-bit B10G10R10G10 Block size 8 bytes 1 texel/block	`VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16`
64-bit R12G12B12A12 Block size 8 bytes 1 texel/block	`VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16`
64-bit G12B12G12R12 Block size 8 bytes 1 texel/block	`VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16`
64-bit B12G12R12G12 Block size 8 bytes 1 texel/block	`VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16`
64-bit G16B16G16R16 Block size 8 bytes 1 texel/block	`VK_FORMAT_G16B16G16R16_422_UNORM`
64-bit B16G16R16G16 Block size 8 bytes 1 texel/block	`VK_FORMAT_B16G16R16G16_422_UNORM`
96-bit Block size 12 bytes 1 texel/block	`VK_FORMAT_R32G32B32_UINT`, `VK_FORMAT_R32G32B32_SINT`, `VK_FORMAT_R32G32B32_SFLOAT`
128-bit Block size 16 bytes 1 texel/block	`VK_FORMAT_R32G32B32A32_UINT`, `VK_FORMAT_R32G32B32A32_SINT`, `VK_FORMAT_R32G32B32A32_SFLOAT`, `VK_FORMAT_R64G64_UINT`, `VK_FORMAT_R64G64_SINT`, `VK_FORMAT_R64G64_SFLOAT`
192-bit Block size 24 bytes 1 texel/block	`VK_FORMAT_R64G64B64_UINT`, `VK_FORMAT_R64G64B64_SINT`, `VK_FORMAT_R64G64B64_SFLOAT`
256-bit Block size 32 bytes 1 texel/block	`VK_FORMAT_R64G64B64A64_UINT`, `VK_FORMAT_R64G64B64A64_SINT`, `VK_FORMAT_R64G64B64A64_SFLOAT`
BC1_RGB (64 bit) Block size 8 bytes 16 texels/block	`VK_FORMAT_BC1_RGB_UNORM_BLOCK`, `VK_FORMAT_BC1_RGB_SRGB_BLOCK`
BC1_RGBA (64 bit) Block size 8 bytes 16 texels/block	`VK_FORMAT_BC1_RGBA_UNORM_BLOCK`, `VK_FORMAT_BC1_RGBA_SRGB_BLOCK`
BC2 (128 bit) Block size 16 bytes 16 texels/block	`VK_FORMAT_BC2_UNORM_BLOCK`, `VK_FORMAT_BC2_SRGB_BLOCK`
BC3 (128 bit) Block size 16 bytes 16 texels/block	`VK_FORMAT_BC3_UNORM_BLOCK`, `VK_FORMAT_BC3_SRGB_BLOCK`
BC4 (64 bit) Block size 8 bytes 16 texels/block	`VK_FORMAT_BC4_UNORM_BLOCK`, `VK_FORMAT_BC4_SNORM_BLOCK`
BC5 (128 bit) Block size 16 bytes 16 texels/block	`VK_FORMAT_BC5_UNORM_BLOCK`, `VK_FORMAT_BC5_SNORM_BLOCK`
BC6H (128 bit) Block size 16 bytes 16 texels/block	`VK_FORMAT_BC6H_UFLOAT_BLOCK`, `VK_FORMAT_BC6H_SFLOAT_BLOCK`
BC7 (128 bit) Block size 16 bytes 16 texels/block	`VK_FORMAT_BC7_UNORM_BLOCK`, `VK_FORMAT_BC7_SRGB_BLOCK`
ETC2_RGB (64 bit) Block size 8 bytes 16 texels/block	`VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK`, `VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK`
ETC2_RGBA (64 bit) Block size 8 bytes 16 texels/block	`VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK`, `VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK`
ETC2_EAC_RGBA (64 bit) Block size 8 bytes 16 texels/block	`VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK`, `VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK`
EAC_R (64 bit) Block size 8 bytes 16 texels/block	`VK_FORMAT_EAC_R11_UNORM_BLOCK`, `VK_FORMAT_EAC_R11_SNORM_BLOCK`
EAC_RG (128 bit) Block size 16 bytes 16 texels/block	`VK_FORMAT_EAC_R11G11_UNORM_BLOCK`, `VK_FORMAT_EAC_R11G11_SNORM_BLOCK`
ASTC_4x4 (128 bit) Block size 16 bytes 16 texels/block	`VK_FORMAT_ASTC_4x4_UNORM_BLOCK`, `VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT`, `VK_FORMAT_ASTC_4x4_SRGB_BLOCK`
ASTC_5x4 (128 bit) Block size 16 bytes 20 texels/block	`VK_FORMAT_ASTC_5x4_UNORM_BLOCK`, `VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT`, `VK_FORMAT_ASTC_5x4_SRGB_BLOCK`
ASTC_5x5 (128 bit) Block size 16 bytes 25 texels/block	`VK_FORMAT_ASTC_5x5_UNORM_BLOCK`, `VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT`, `VK_FORMAT_ASTC_5x5_SRGB_BLOCK`
ASTC_6x5 (128 bit) Block size 16 bytes 30 texels/block	`VK_FORMAT_ASTC_6x5_UNORM_BLOCK`, `VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT`, `VK_FORMAT_ASTC_6x5_SRGB_BLOCK`
ASTC_6x6 (128 bit) Block size 16 bytes 36 texels/block	`VK_FORMAT_ASTC_6x6_UNORM_BLOCK`, `VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT`, `VK_FORMAT_ASTC_6x6_SRGB_BLOCK`
ASTC_8x5 (128 bit) Block size 16 bytes 40 texels/block	`VK_FORMAT_ASTC_8x5_UNORM_BLOCK`, `VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT`, `VK_FORMAT_ASTC_8x5_SRGB_BLOCK`
ASTC_8x6 (128 bit) Block size 16 bytes 48 texels/block	`VK_FORMAT_ASTC_8x6_UNORM_BLOCK`, `VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT`, `VK_FORMAT_ASTC_8x6_SRGB_BLOCK`
ASTC_8x8 (128 bit) Block size 16 bytes 64 texels/block	`VK_FORMAT_ASTC_8x8_UNORM_BLOCK`, `VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT`, `VK_FORMAT_ASTC_8x8_SRGB_BLOCK`
ASTC_10x5 (128 bit) Block size 16 bytes 50 texels/block	`VK_FORMAT_ASTC_10x5_UNORM_BLOCK`, `VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT`, `VK_FORMAT_ASTC_10x5_SRGB_BLOCK`
ASTC_10x6 (128 bit) Block size 16 bytes 60 texels/block	`VK_FORMAT_ASTC_10x6_UNORM_BLOCK`, `VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT`, `VK_FORMAT_ASTC_10x6_SRGB_BLOCK`
ASTC_10x8 (128 bit) Block size 16 bytes 80 texels/block	`VK_FORMAT_ASTC_10x8_UNORM_BLOCK`, `VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT`, `VK_FORMAT_ASTC_10x8_SRGB_BLOCK`
ASTC_10x10 (128 bit) Block size 16 bytes 100 texels/block	`VK_FORMAT_ASTC_10x10_UNORM_BLOCK`, `VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT`, `VK_FORMAT_ASTC_10x10_SRGB_BLOCK`
ASTC_12x10 (128 bit) Block size 16 bytes 120 texels/block	`VK_FORMAT_ASTC_12x10_UNORM_BLOCK`, `VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT`, `VK_FORMAT_ASTC_12x10_SRGB_BLOCK`
ASTC_12x12 (128 bit) Block size 16 bytes 144 texels/block	`VK_FORMAT_ASTC_12x12_UNORM_BLOCK`, `VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT`, `VK_FORMAT_ASTC_12x12_SRGB_BLOCK`
D16 (16 bit) Block size 2 bytes 1 texel/block	`VK_FORMAT_D16_UNORM`
D24 (32 bit) Block size 4 bytes 1 texel/block	`VK_FORMAT_X8_D24_UNORM_PACK32`
D32 (32 bit) Block size 4 bytes 1 texel/block	`VK_FORMAT_D32_SFLOAT`
S8 (8 bit) Block size 1 byte 1 texel/block	`VK_FORMAT_S8_UINT`
D16S8 (24 bit) Block size 3 bytes 1 texel/block	`VK_FORMAT_D16_UNORM_S8_UINT`
D24S8 (32 bit) Block size 4 bytes 1 texel/block	`VK_FORMAT_D24_UNORM_S8_UINT`
D32S8 (40 bit) Block size 5 bytes 1 texel/block	`VK_FORMAT_D32_SFLOAT_S8_UINT`
8-bit 3-plane 420 Block size (1,1,1) bytes 1 texel/block	`VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM`
8-bit 2-plane 420 Block size (1,2) bytes 1 texel/block	`VK_FORMAT_G8_B8R8_2PLANE_420_UNORM`
8-bit 3-plane 422 Block size (1,1,1) bytes 1 texel/block	`VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM`
8-bit 2-plane 422 Block size (1,2) bytes 1 texel/block	`VK_FORMAT_G8_B8R8_2PLANE_422_UNORM`
8-bit 3-plane 444 Block size (1,1,1) bytes 1 texel/block	`VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM`
10-bit 3-plane 420 Block size (2,2,2) bytes 1 texel/block	`VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16`
10-bit 2-plane 420 Block size (2,4) bytes 1 texel/block	`VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16`
10-bit 3-plane 422 Block size (2,2,2) bytes 1 texel/block	`VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16`
10-bit 2-plane 422 Block size (2,2) bytes 1 texel/block	`VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16`
10-bit 3-plane 444 Block size (2,2,2) bytes 1 texel/block	`VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16`
12-bit 3-plane 420 Block size (2,2,2) bytes 1 texel/block	`VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16`
12-bit 2-plane 420 Block size (2,4) bytes 1 texel/block	`VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16`
12-bit 3-plane 422 Block size (2,2,2) bytes 1 texel/block	`VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16`
12-bit 2-plane 422 Block size (2,4) bytes 1 texel/block	`VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16`
12-bit 3-plane 444 Block size (2,2,2) bytes 1 texel/block	`VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16`
16-bit 3-plane 420 Block size (2,2,2) bytes 1 texel/block	`VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM`
16-bit 2-plane 420 Block size (2,4) bytes 1 texel/block	`VK_FORMAT_G16_B16R16_2PLANE_420_UNORM`
16-bit 3-plane 422 Block size (2,2,2) bytes 1 texel/block	`VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM`
16-bit 2-plane 422 Block size (2,4) bytes 1 texel/block	`VK_FORMAT_G16_B16R16_2PLANE_422_UNORM`
16-bit 3-plane 444 Block size (2,2,2) bytes 1 texel/block	`VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM`

37.2. Format Properties

To query supported format features which are properties of the physical device, call:

void vkGetPhysicalDeviceFormatProperties(
    VkPhysicalDevice                            physicalDevice,
    VkFormat                                    format,
    VkFormatProperties*                         pFormatProperties);

physicalDevice is the physical device from which to query the format properties.
format is the format whose properties are queried.
pFormatProperties is a pointer to a VkFormatProperties structure in which physical device properties for format are returned.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceFormatProperties-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceFormatProperties-format-parameter
format must be a valid VkFormat value
VUID-vkGetPhysicalDeviceFormatProperties-pFormatProperties-parameter
pFormatProperties must be a valid pointer to a VkFormatProperties structure

The VkFormatProperties structure is defined as:

typedef struct VkFormatProperties {
    VkFormatFeatureFlags    linearTilingFeatures;
    VkFormatFeatureFlags    optimalTilingFeatures;
    VkFormatFeatureFlags    bufferFeatures;
} VkFormatProperties;

linearTilingFeatures is a bitmask of VkFormatFeatureFlagBits specifying features supported by images created with a tiling parameter of VK_IMAGE_TILING_LINEAR.
optimalTilingFeatures is a bitmask of VkFormatFeatureFlagBits specifying features supported by images created with a tiling parameter of VK_IMAGE_TILING_OPTIMAL.
bufferFeatures is a bitmask of VkFormatFeatureFlagBits specifying features supported by buffers.

Note

If no format feature flags are supported, the format itself is not supported, and images of that format cannot be created.

If format is a block-compressed format, then bufferFeatures must not support any features for the format.

If format is not a multi-plane format then linearTilingFeatures and optimalTilingFeatures must not contain VK_FORMAT_FEATURE_DISJOINT_BIT.

Bits which can be set in the VkFormatProperties features linearTilingFeatures, optimalTilingFeatures, drmFormatModifierTilingFeatures, and bufferFeatures are:

typedef enum VkFormatFeatureFlagBits {
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
    VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
    VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
    VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
    VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
    VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
    VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
    VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
    VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000,
    VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000,
    VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000,
    VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000,
    VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000,
    VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000,
    VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
    VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT,
    VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT,
    VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT,
    VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,
    VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkFormatFeatureFlagBits;

The following bits may be set in linearTilingFeatures, optimalTilingFeatures, and drmFormatModifierTilingFeatures, specifying that the features are supported by images or image views created with the queried vkGetPhysicalDeviceFormatProperties::format:

VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT specifies that an image view can be sampled from.
VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT specifies that an image view can be used as a storage images.
VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT specifies that an image view can be used as storage image that supports atomic operations.
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT specifies that an image view can be used as a framebuffer color attachment and as an input attachment.
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT specifies that an image view can be used as a framebuffer color attachment that supports blending and as an input attachment.
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT specifies that an image view can be used as a framebuffer depth/stencil attachment and as an input attachment.
VK_FORMAT_FEATURE_BLIT_SRC_BIT specifies that an image can be used as srcImage for the vkCmdBlitImage command.
VK_FORMAT_FEATURE_BLIT_DST_BIT specifies that an image can be used as dstImage for the vkCmdBlitImage command.
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT specifies that if VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT is also set, an image view can be used with a sampler that has either of magFilter or minFilter set to VK_FILTER_LINEAR, or mipmapMode set to VK_SAMPLER_MIPMAP_MODE_LINEAR. If VK_FORMAT_FEATURE_BLIT_SRC_BIT is also set, an image can be used as the srcImage to vkCmdBlitImage with a filter of VK_FILTER_LINEAR. This bit must only be exposed for formats that also support the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT or VK_FORMAT_FEATURE_BLIT_SRC_BIT.

If the format being queried is a depth/stencil format, this bit only specifies that the depth aspect (not the stencil aspect) of an image of this format 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.
VK_FORMAT_FEATURE_TRANSFER_SRC_BIT specifies that an image can be used as a source image for copy commands.
VK_FORMAT_FEATURE_TRANSFER_DST_BIT specifies that an image can be used as a destination image for copy commands and clear commands.
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT specifies VkImage can be used as a sampled image with a min or max VkSamplerReductionMode. This bit must only be exposed for formats that also support the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT.
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT specifies that VkImage can be used with a sampler that has either of magFilter or minFilter set to VK_FILTER_CUBIC_EXT, or be the source image for a blit with filter set to VK_FILTER_CUBIC_EXT. This bit must only be exposed for formats that also support the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT. If the format being queried is a depth/stencil format, this only specifies that the depth aspect is cubic filterable.
VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT specifies that an application can define a sampler Y′C_BC_R conversion using this format as a source, and that an image of this format can be used with a VkSamplerYcbcrConversionCreateInfo xChromaOffset and/or yChromaOffset of VK_CHROMA_LOCATION_MIDPOINT. Otherwise both xChromaOffset and yChromaOffset must be VK_CHROMA_LOCATION_COSITED_EVEN. If a format does not incorporate chroma downsampling (it is not a “422” or “420” format) but the implementation supports sampler Y′C_BC_R conversion for this format, the implementation must set VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT.
VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT specifies that an application can define a sampler Y′C_BC_R conversion using this format as a source, and that an image of this format can be used with a VkSamplerYcbcrConversionCreateInfo xChromaOffset and/or yChromaOffset of VK_CHROMA_LOCATION_COSITED_EVEN. Otherwise both xChromaOffset and yChromaOffset must be VK_CHROMA_LOCATION_MIDPOINT. If neither VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT nor VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT is set, the application must not define a sampler Y′C_BC_R conversion using this format as a source.
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT specifies that the format can do linear sampler filtering (min/magFilter) whilst sampler Y′C_BC_R conversion is enabled.
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT specifies that the format can have different chroma, min, and mag filters.
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT specifies that reconstruction is explicit, as described in Chroma Reconstruction. If this bit is not present, reconstruction is implicit by default.
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT specifies that reconstruction can be forcibly made explicit by setting VkSamplerYcbcrConversionCreateInfo::forceExplicitReconstruction to VK_TRUE. If the format being queried supports VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT it must also support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT.
VK_FORMAT_FEATURE_DISJOINT_BIT specifies that a multi-planar image can have the VK_IMAGE_CREATE_DISJOINT_BIT set during image creation. An implementation must not set VK_FORMAT_FEATURE_DISJOINT_BIT for single-plane formats.
VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT specifies that an image view can be used as a fragment density map attachment.

The following bits may be set in bufferFeatures, specifying that the features are supported by buffers or buffer views created with the queried vkGetPhysicalDeviceProperties::format:

VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT specifies that the format can be used to create a buffer view that can be bound to a VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER descriptor.
VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT specifies that the format can be used to create a buffer view that can be bound to a VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER descriptor.
VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT specifies that atomic operations are supported on VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER with this format.
VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT specifies that the format can be used as a vertex attribute format (VkVertexInputAttributeDescription::format).

typedef VkFlags VkFormatFeatureFlags;

VkFormatFeatureFlags is a bitmask type for setting a mask of zero or more VkFormatFeatureFlagBits.

To query supported format features which are properties of the physical device, call:

void vkGetPhysicalDeviceFormatProperties2(
    VkPhysicalDevice                            physicalDevice,
    VkFormat                                    format,
    VkFormatProperties2*                        pFormatProperties);

or the equivalent command

void vkGetPhysicalDeviceFormatProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    VkFormat                                    format,
    VkFormatProperties2*                        pFormatProperties);

physicalDevice is the physical device from which to query the format properties.
format is the format whose properties are queried.
pFormatProperties is a pointer to a VkFormatProperties2 structure in which physical device properties for format are returned.

vkGetPhysicalDeviceFormatProperties2 behaves similarly to vkGetPhysicalDeviceFormatProperties, with the ability to return extended information in a pNext chain of output structures.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceFormatProperties2-format-parameter
format must be a valid VkFormat value
VUID-vkGetPhysicalDeviceFormatProperties2-pFormatProperties-parameter
pFormatProperties must be a valid pointer to a VkFormatProperties2 structure

The VkFormatProperties2 structure is defined as:

typedef struct VkFormatProperties2 {
    VkStructureType       sType;
    void*                 pNext;
    VkFormatProperties    formatProperties;
} VkFormatProperties2;

or the equivalent

typedef VkFormatProperties2 VkFormatProperties2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
formatProperties is a VkFormatProperties structure describing features supported by the requested format.

Valid Usage (Implicit)

VUID-VkFormatProperties2-sType-sType
sType must be VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2
VUID-VkFormatProperties2-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkDrmFormatModifierPropertiesListEXT
VUID-VkFormatProperties2-sType-unique
The sType value of each struct in the pNext chain must be unique

To obtain the list of Linux DRM format modifiers compatible with a VkFormat, add a VkDrmFormatModifierPropertiesListEXT structure to the pNext chain of VkFormatProperties2.

The VkDrmFormatModifierPropertiesListEXT structure is defined as:

typedef struct VkDrmFormatModifierPropertiesListEXT {
    VkStructureType                      sType;
    void*                                pNext;
    uint32_t                             drmFormatModifierCount;
    VkDrmFormatModifierPropertiesEXT*    pDrmFormatModifierProperties;
} VkDrmFormatModifierPropertiesListEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
drmFormatModifierCount is an inout parameter related to the number of modifiers compatible with the format, as described below.
pDrmFormatModifierProperties is either NULL or an array of VkDrmFormatModifierPropertiesEXT structures.

If pDrmFormatModifierProperties is NULL, then the function returns in drmFormatModifierCount the number of modifiers compatible with the queried format. Otherwise, the application must set drmFormatModifierCount to the length of the array pDrmFormatModifierProperties; the function will write at most drmFormatModifierCount elements to the array, and will return in drmFormatModifierCount the number of elements written.

Among the elements in array pDrmFormatModifierProperties, each returned drmFormatModifier must be unique.

Valid Usage (Implicit)

VUID-VkDrmFormatModifierPropertiesListEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT

The VkDrmFormatModifierPropertiesEXT structure describes properties of a VkFormat when that format is combined with a Linux DRM format modifier. These properties, like those of VkFormatProperties2, are independent of any particular image.

The VkDrmFormatModifierPropertiesEXT structure is defined as:

typedef struct VkDrmFormatModifierPropertiesEXT {
    uint64_t                drmFormatModifier;
    uint32_t                drmFormatModifierPlaneCount;
    VkFormatFeatureFlags    drmFormatModifierTilingFeatures;
} VkDrmFormatModifierPropertiesEXT;

drmFormatModifier is a Linux DRM format modifier.
drmFormatModifierPlaneCount is the number of memory planes in any image created with format and drmFormatModifier. An image’s memory planecount is distinct from its format planecount, as explained below.
drmFormatModifierTilingFeatures is a bitmask of VkFormatFeatureFlagBits that are supported by any image created with format and drmFormatModifier.

The returned drmFormatModifierTilingFeatures must contain at least one bit.

The implementation must not return DRM_FORMAT_MOD_INVALID in drmFormatModifier.

An image’s memory planecount (as returned by drmFormatModifierPlaneCount) is distinct from its format planecount (in the sense of multi-planar Y′C_BC_R formats). In VkImageAspectFlags, each VK_IMAGE_ASPECT_MEMORY_PLANEi_BIT_EXT represents a _memory plane and each VK_IMAGE_ASPECT_PLANEi_BIT a _format plane.

An image’s set of format planes is an ordered partition of the image’s content into separable groups of format channels. The ordered partition is encoded in the name of each VkFormat. For example, VK_FORMAT_G8_B8R8_2PLANE_420_UNORM contains two format planes; the first plane contains the green channel and the second plane contains the blue channel and red channel. If the format name does not contain PLANE, then the format contains a single plane; for example, VK_FORMAT_R8G8B8A8_UNORM. Some commands, such as vkCmdCopyBufferToImage, do not operate on all format channels in the image, but instead operate only on the format planes explicitly chosen by the application and operate on each format plane independently.

An image’s set of memory planes is an ordered partition of the image’s memory rather than the image’s content. Each memory plane is a contiguous range of memory. The union of an image’s memory planes is not necessarily contiguous.

If an image is linear, then the partition is the same for memory planes and for format planes. Therefore, if the returned drmFormatModifier is DRM_FORMAT_MOD_LINEAR, then drmFormatModifierPlaneCount must equal the format planecount, and drmFormatModifierTilingFeatures must be identical to the VkFormatProperties2::linearTilingFeatures returned in the same pNext chain.

If an image is non-linear, then the partition of the image’s memory into memory planes is implementation-specific and may be unrelated to the partition of the image’s content into format planes. For example, consider an image whose format is VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, whose drmFormatModifier is not DRM_FORMAT_MOD_LINEAR, and flags lacks VK_IMAGE_CREATE_DISJOINT_BIT. The image has 3 format planes, and commands such vkCmdCopyBufferToImage act on each format plane independently as if the data of each format plane were separable from the data of the other planes. In a straightforward implementation, the implementation may store the image’s content in 3 adjacent memory planes where each memory plane corresponds exactly to a format plane. However, the implementation may also store the image’s content in a single memory plane where all format channels are combined using an implementation-private block-compressed format; or the implementation may store the image’s content in a collection of 7 adjacent memory planes using an implementation-private sharding technique. Because the image is non-linear and non-disjoint, the implementation has much freedom when choosing the image’s placement in memory.

The memory planecount applies to function parameters and structures only when the API specifies an explicit requirement on drmFormatModifierPlaneCount. In all other cases, the memory planecount is ignored.

37.3. Required Format Support

Implementations must support at least the following set of features on the listed formats. For images, these features must be supported for every VkImageType (including arrayed and cube variants) unless otherwise noted. These features are supported on existing formats without needing to advertise an extension or needing to explicitly enable them. Support for additional functionality beyond the requirements listed here is queried using the vkGetPhysicalDeviceFormatProperties command.

Note

Unless otherwise excluded below, the required formats are supported for all VkImageCreateFlags values as long as those flag values are otherwise allowed.

The following tables show which feature bits must be supported for each format. Formats that are required to support VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT must also support VK_FORMAT_FEATURE_TRANSFER_SRC_BIT and VK_FORMAT_FEATURE_TRANSFER_DST_BIT.

Table 55. Key for format feature tables
✓	This feature must be supported on the named format
†	This feature must be supported on at least some of the named formats, with more information in the table where the symbol appears
‡	This feature must be supported with some caveats or preconditions, with more information in the table where the symbol appears

Table 56. Feature bits in `optimalTilingFeatures`
`VK_FORMAT_FEATURE_TRANSFER_SRC_BIT`
`VK_FORMAT_FEATURE_TRANSFER_DST_BIT`
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`
`VK_FORMAT_FEATURE_BLIT_SRC_BIT`
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT`
`VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT`
`VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT`
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT`
`VK_FORMAT_FEATURE_BLIT_DST_BIT`
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT`
`VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT`
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT`

Table 57. Feature bits in `bufferFeatures`
`VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT`
`VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT`
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT`
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT`

Table 58. Mandatory format support: sub-byte channels
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT`													↓
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT`												↓
`VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT`											↓
`VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT`										↓
`VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT`									↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT`								↓
`VK_FORMAT_FEATURE_BLIT_DST_BIT`							↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT`						↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT`					↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT`				↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT`			↓
`VK_FORMAT_FEATURE_BLIT_SRC_BIT`		↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`	↓
Format	↓
`VK_FORMAT_UNDEFINED`
`VK_FORMAT_R4G4_UNORM_PACK8`
`VK_FORMAT_R4G4B4A4_UNORM_PACK16`
`VK_FORMAT_B4G4R4A4_UNORM_PACK16`	✓	✓	✓
`VK_FORMAT_R5G6B5_UNORM_PACK16`	✓	✓	✓			✓	✓	✓
`VK_FORMAT_B5G6R5_UNORM_PACK16`
`VK_FORMAT_R5G5B5A1_UNORM_PACK16`
`VK_FORMAT_B5G5R5A1_UNORM_PACK16`
`VK_FORMAT_A1R5G5B5_UNORM_PACK16`	✓	✓	✓			✓	✓	✓

Table 59. Mandatory format support: 1-3 byte-sized channels
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT`													↓
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT`												↓
`VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT`											↓
`VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT`										↓
`VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT`									↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT`								↓
`VK_FORMAT_FEATURE_BLIT_DST_BIT`							↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT`						↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT`					↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT`				↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT`			↓
`VK_FORMAT_FEATURE_BLIT_SRC_BIT`		↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`	↓
Format	↓
`VK_FORMAT_R8_UNORM`	✓	✓	✓	‡		✓	✓	✓		✓	✓
`VK_FORMAT_R8_SNORM`	✓	✓	✓	‡						✓	✓
`VK_FORMAT_R8_USCALED`
`VK_FORMAT_R8_SSCALED`
`VK_FORMAT_R8_UINT`	✓	✓		‡		✓	✓			✓	✓
`VK_FORMAT_R8_SINT`	✓	✓		‡		✓	✓			✓	✓
`VK_FORMAT_R8_SRGB`
`VK_FORMAT_R8G8_UNORM`	✓	✓	✓	‡		✓	✓	✓		✓	✓
`VK_FORMAT_R8G8_SNORM`	✓	✓	✓	‡						✓	✓
`VK_FORMAT_R8G8_USCALED`
`VK_FORMAT_R8G8_SSCALED`
`VK_FORMAT_R8G8_UINT`	✓	✓		‡		✓	✓			✓	✓
`VK_FORMAT_R8G8_SINT`	✓	✓		‡		✓	✓			✓	✓
`VK_FORMAT_R8G8_SRGB`
`VK_FORMAT_R8G8B8_UNORM`
`VK_FORMAT_R8G8B8_SNORM`
`VK_FORMAT_R8G8B8_USCALED`
`VK_FORMAT_R8G8B8_SSCALED`
`VK_FORMAT_R8G8B8_UINT`
`VK_FORMAT_R8G8B8_SINT`
`VK_FORMAT_R8G8B8_SRGB`
`VK_FORMAT_B8G8R8_UNORM`
`VK_FORMAT_B8G8R8_SNORM`
`VK_FORMAT_B8G8R8_USCALED`
`VK_FORMAT_B8G8R8_SSCALED`
`VK_FORMAT_B8G8R8_UINT`
`VK_FORMAT_B8G8R8_SINT`
`VK_FORMAT_B8G8R8_SRGB`
Format features marked with ‡ must be supported for `optimalTilingFeatures` if the `VkPhysicalDevice` supports the `shaderStorageImageExtendedFormats` feature.

Table 60. Mandatory format support: 4 byte-sized channels
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT`													↓
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT`												↓
`VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT`											↓
`VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT`										↓
`VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT`									↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT`								↓
`VK_FORMAT_FEATURE_BLIT_DST_BIT`							↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT`						↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT`					↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT`				↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT`			↓
`VK_FORMAT_FEATURE_BLIT_SRC_BIT`		↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`	↓
Format	↓
`VK_FORMAT_R8G8B8A8_UNORM`	✓	✓	✓	✓		✓	✓	✓		✓	✓	✓
`VK_FORMAT_R8G8B8A8_SNORM`	✓	✓	✓	✓						✓	✓	✓
`VK_FORMAT_R8G8B8A8_USCALED`
`VK_FORMAT_R8G8B8A8_SSCALED`
`VK_FORMAT_R8G8B8A8_UINT`	✓	✓		✓		✓	✓			✓	✓	✓
`VK_FORMAT_R8G8B8A8_SINT`	✓	✓		✓		✓	✓			✓	✓	✓
`VK_FORMAT_R8G8B8A8_SRGB`	✓	✓	✓			✓	✓	✓
`VK_FORMAT_B8G8R8A8_UNORM`	✓	✓	✓			✓	✓	✓		✓	✓
`VK_FORMAT_B8G8R8A8_SNORM`
`VK_FORMAT_B8G8R8A8_USCALED`
`VK_FORMAT_B8G8R8A8_SSCALED`
`VK_FORMAT_B8G8R8A8_UINT`
`VK_FORMAT_B8G8R8A8_SINT`
`VK_FORMAT_B8G8R8A8_SRGB`	✓	✓	✓			✓	✓	✓
`VK_FORMAT_A8B8G8R8_UNORM_PACK32`	✓	✓	✓			✓	✓	✓		✓	✓	✓
`VK_FORMAT_A8B8G8R8_SNORM_PACK32`	✓	✓	✓							✓	✓	✓
`VK_FORMAT_A8B8G8R8_USCALED_PACK32`
`VK_FORMAT_A8B8G8R8_SSCALED_PACK32`
`VK_FORMAT_A8B8G8R8_UINT_PACK32`	✓	✓				✓	✓			✓	✓	✓
`VK_FORMAT_A8B8G8R8_SINT_PACK32`	✓	✓				✓	✓			✓	✓	✓
`VK_FORMAT_A8B8G8R8_SRGB_PACK32`	✓	✓	✓			✓	✓	✓

Table 61. Mandatory format support: 10- and 12-bit channels
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT`													↓
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT`												↓
`VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT`											↓
`VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT`										↓
`VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT`									↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT`								↓
`VK_FORMAT_FEATURE_BLIT_DST_BIT`							↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT`						↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT`					↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT`				↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT`			↓
`VK_FORMAT_FEATURE_BLIT_SRC_BIT`		↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`	↓
Format	↓
`VK_FORMAT_A2R10G10B10_UNORM_PACK32`
`VK_FORMAT_A2R10G10B10_SNORM_PACK32`
`VK_FORMAT_A2R10G10B10_USCALED_PACK32`
`VK_FORMAT_A2R10G10B10_SSCALED_PACK32`
`VK_FORMAT_A2R10G10B10_UINT_PACK32`
`VK_FORMAT_A2R10G10B10_SINT_PACK32`
`VK_FORMAT_A2B10G10R10_UNORM_PACK32`	✓	✓	✓	‡		✓	✓	✓		✓	✓
`VK_FORMAT_A2B10G10R10_SNORM_PACK32`
`VK_FORMAT_A2B10G10R10_USCALED_PACK32`
`VK_FORMAT_A2B10G10R10_SSCALED_PACK32`
`VK_FORMAT_A2B10G10R10_UINT_PACK32`	✓	✓		‡		✓	✓				✓
`VK_FORMAT_A2B10G10R10_SINT_PACK32`
`VK_FORMAT_R10X6_UNORM_PACK16`
`VK_FORMAT_R10X6G10X6_UNORM_2PACK16`
`VK_FORMAT_R12X4_UNORM_PACK16`
`VK_FORMAT_R12X4G12X4_UNORM_2PACK16`
Format features marked with ‡ must be supported for `optimalTilingFeatures` if the `VkPhysicalDevice` supports the `shaderStorageImageExtendedFormats` feature.

Table 62. Mandatory format support: 16-bit channels
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT`													↓
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT`												↓
`VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT`											↓
`VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT`										↓
`VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT`									↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT`								↓
`VK_FORMAT_FEATURE_BLIT_DST_BIT`							↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT`						↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT`					↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT`				↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT`			↓
`VK_FORMAT_FEATURE_BLIT_SRC_BIT`		↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`	↓
Format	↓
`VK_FORMAT_R16_UNORM`				‡						✓
`VK_FORMAT_R16_SNORM`				‡						✓
`VK_FORMAT_R16_USCALED`
`VK_FORMAT_R16_SSCALED`
`VK_FORMAT_R16_UINT`	✓	✓		‡		✓	✓			✓	✓
`VK_FORMAT_R16_SINT`	✓	✓		‡		✓	✓			✓	✓
`VK_FORMAT_R16_SFLOAT`	✓	✓	✓	‡		✓	✓	✓		✓	✓
`VK_FORMAT_R16G16_UNORM`				‡						✓
`VK_FORMAT_R16G16_SNORM`				‡						✓
`VK_FORMAT_R16G16_USCALED`
`VK_FORMAT_R16G16_SSCALED`
`VK_FORMAT_R16G16_UINT`	✓	✓		‡		✓	✓			✓	✓
`VK_FORMAT_R16G16_SINT`	✓	✓		‡		✓	✓			✓	✓
`VK_FORMAT_R16G16_SFLOAT`	✓	✓	✓	‡		✓	✓	✓		✓	✓
`VK_FORMAT_R16G16B16_UNORM`
`VK_FORMAT_R16G16B16_SNORM`
`VK_FORMAT_R16G16B16_USCALED`
`VK_FORMAT_R16G16B16_SSCALED`
`VK_FORMAT_R16G16B16_UINT`
`VK_FORMAT_R16G16B16_SINT`
`VK_FORMAT_R16G16B16_SFLOAT`
`VK_FORMAT_R16G16B16A16_UNORM`				‡						✓
`VK_FORMAT_R16G16B16A16_SNORM`				‡						✓
`VK_FORMAT_R16G16B16A16_USCALED`
`VK_FORMAT_R16G16B16A16_SSCALED`
`VK_FORMAT_R16G16B16A16_UINT`	✓	✓		✓		✓	✓			✓	✓	✓
`VK_FORMAT_R16G16B16A16_SINT`	✓	✓		✓		✓	✓			✓	✓	✓
`VK_FORMAT_R16G16B16A16_SFLOAT`	✓	✓	✓	✓		✓	✓	✓		✓	✓	✓
Format features marked with ‡ must be supported for `optimalTilingFeatures` if the `VkPhysicalDevice` supports the `shaderStorageImageExtendedFormats` feature.

Table 63. Mandatory format support: 32-bit channels
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT`													↓
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT`												↓
`VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT`											↓
`VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT`										↓
`VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT`									↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT`								↓
`VK_FORMAT_FEATURE_BLIT_DST_BIT`							↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT`						↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT`					↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT`				↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT`			↓
`VK_FORMAT_FEATURE_BLIT_SRC_BIT`		↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`	↓
Format	↓
`VK_FORMAT_R32_UINT`	✓	✓		✓	✓	✓	✓			✓	✓	✓	✓
`VK_FORMAT_R32_SINT`	✓	✓		✓	✓	✓	✓			✓	✓	✓	✓
`VK_FORMAT_R32_SFLOAT`	✓	✓		✓		✓	✓			✓	✓	✓
`VK_FORMAT_R32G32_UINT`	✓	✓		✓		✓	✓			✓	✓	✓
`VK_FORMAT_R32G32_SINT`	✓	✓		✓		✓	✓			✓	✓	✓
`VK_FORMAT_R32G32_SFLOAT`	✓	✓		✓		✓	✓			✓	✓	✓
`VK_FORMAT_R32G32B32_UINT`										✓
`VK_FORMAT_R32G32B32_SINT`										✓
`VK_FORMAT_R32G32B32_SFLOAT`										✓
`VK_FORMAT_R32G32B32A32_UINT`	✓	✓		✓		✓	✓			✓	✓	✓
`VK_FORMAT_R32G32B32A32_SINT`	✓	✓		✓		✓	✓			✓	✓	✓
`VK_FORMAT_R32G32B32A32_SFLOAT`	✓	✓		✓		✓	✓			✓	✓	✓

Table 64. Mandatory format support: 64-bit/uneven channels
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT`													↓
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT`												↓
`VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT`											↓
`VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT`										↓
`VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT`									↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT`								↓
`VK_FORMAT_FEATURE_BLIT_DST_BIT`							↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT`						↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT`					↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT`				↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT`			↓
`VK_FORMAT_FEATURE_BLIT_SRC_BIT`		↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`	↓
Format	↓
`VK_FORMAT_R64_UINT`
`VK_FORMAT_R64_SINT`
`VK_FORMAT_R64_SFLOAT`
`VK_FORMAT_R64G64_UINT`
`VK_FORMAT_R64G64_SINT`
`VK_FORMAT_R64G64_SFLOAT`
`VK_FORMAT_R64G64B64_UINT`
`VK_FORMAT_R64G64B64_SINT`
`VK_FORMAT_R64G64B64_SFLOAT`
`VK_FORMAT_R64G64B64A64_UINT`
`VK_FORMAT_R64G64B64A64_SINT`
`VK_FORMAT_R64G64B64A64_SFLOAT`
`VK_FORMAT_B10G11R11_UFLOAT_PACK32`	✓	✓	✓	‡							✓
`VK_FORMAT_E5B9G9R9_UFLOAT_PACK32`	✓	✓	✓
Format features marked with ‡ must be supported for `optimalTilingFeatures` if the `VkPhysicalDevice` supports the `shaderStorageImageExtendedFormats` feature.

Table 65. Mandatory format support: depth/stencil with `VkImageType` `VK_IMAGE_TYPE_2D`
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT`													↓
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT`												↓
`VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT`											↓
`VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT`										↓
`VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT`									↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT`								↓
`VK_FORMAT_FEATURE_BLIT_DST_BIT`							↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT`						↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT`					↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT`				↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT`			↓
`VK_FORMAT_FEATURE_BLIT_SRC_BIT`		↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`	↓
Format	↓
`VK_FORMAT_D16_UNORM`	✓	✓							✓
`VK_FORMAT_X8_D24_UNORM_PACK32`									†
`VK_FORMAT_D32_SFLOAT`	✓	✓							†
`VK_FORMAT_S8_UINT`
`VK_FORMAT_D16_UNORM_S8_UINT`
`VK_FORMAT_D24_UNORM_S8_UINT`									†
`VK_FORMAT_D32_SFLOAT_S8_UINT`									†
`VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT` feature must be supported for at least one of `VK_FORMAT_X8_D24_UNORM_PACK32` and `VK_FORMAT_D32_SFLOAT`, and must be supported for at least one of `VK_FORMAT_D24_UNORM_S8_UINT` and `VK_FORMAT_D32_SFLOAT_S8_UINT`.

Table 66. Mandatory format support: BC compressed formats with `VkImageType` `VK_IMAGE_TYPE_2D` and `VK_IMAGE_TYPE_3D`
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT`													↓
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT`												↓
`VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT`											↓
`VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT`										↓
`VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT`									↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT`								↓
`VK_FORMAT_FEATURE_BLIT_DST_BIT`							↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT`						↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT`					↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT`				↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT`			↓
`VK_FORMAT_FEATURE_BLIT_SRC_BIT`		↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`	↓
Format	↓
`VK_FORMAT_BC1_RGB_UNORM_BLOCK`	†	†	†
`VK_FORMAT_BC1_RGB_SRGB_BLOCK`	†	†	†
`VK_FORMAT_BC1_RGBA_UNORM_BLOCK`	†	†	†
`VK_FORMAT_BC1_RGBA_SRGB_BLOCK`	†	†	†
`VK_FORMAT_BC2_UNORM_BLOCK`	†	†	†
`VK_FORMAT_BC2_SRGB_BLOCK`	†	†	†
`VK_FORMAT_BC3_UNORM_BLOCK`	†	†	†
`VK_FORMAT_BC3_SRGB_BLOCK`	†	†	†
`VK_FORMAT_BC4_UNORM_BLOCK`	†	†	†
`VK_FORMAT_BC4_SNORM_BLOCK`	†	†	†
`VK_FORMAT_BC5_UNORM_BLOCK`	†	†	†
`VK_FORMAT_BC5_SNORM_BLOCK`	†	†	†
`VK_FORMAT_BC6H_UFLOAT_BLOCK`	†	†	†
`VK_FORMAT_BC6H_SFLOAT_BLOCK`	†	†	†
`VK_FORMAT_BC7_UNORM_BLOCK`	†	†	†
`VK_FORMAT_BC7_SRGB_BLOCK`	†	†	†
The `VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`, `VK_FORMAT_FEATURE_BLIT_SRC_BIT` and `VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT` features must be supported in `optimalTilingFeatures` for all the formats in at least one of: this table, Mandatory format support: ETC2 and EAC compressed formats with `VkImageType` `VK_IMAGE_TYPE_2D`, or Mandatory format support: ASTC LDR compressed formats with `VkImageType` `VK_IMAGE_TYPE_2D`.

Table 67. Mandatory format support: ETC2 and EAC compressed formats with `VkImageType` `VK_IMAGE_TYPE_2D`
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT`													↓
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT`												↓
`VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT`											↓
`VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT`										↓
`VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT`									↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT`								↓
`VK_FORMAT_FEATURE_BLIT_DST_BIT`							↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT`						↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT`					↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT`				↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT`			↓
`VK_FORMAT_FEATURE_BLIT_SRC_BIT`		↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`	↓
Format	↓
`VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK`	†	†	†
`VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK`	†	†	†
`VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK`	†	†	†
`VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK`	†	†	†
`VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK`	†	†	†
`VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK`	†	†	†
`VK_FORMAT_EAC_R11_UNORM_BLOCK`	†	†	†
`VK_FORMAT_EAC_R11_SNORM_BLOCK`	†	†	†
`VK_FORMAT_EAC_R11G11_UNORM_BLOCK`	†	†	†
`VK_FORMAT_EAC_R11G11_SNORM_BLOCK`	†	†	†
The `VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`, `VK_FORMAT_FEATURE_BLIT_SRC_BIT` and `VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT` features must be supported in `optimalTilingFeatures` for all the formats in at least one of: this table, Mandatory format support: BC compressed formats with `VkImageType` `VK_IMAGE_TYPE_2D` and `VK_IMAGE_TYPE_3D`, or Mandatory format support: ASTC LDR compressed formats with `VkImageType` `VK_IMAGE_TYPE_2D`.

Table 68. Mandatory format support: ASTC LDR compressed formats with `VkImageType` `VK_IMAGE_TYPE_2D`
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT`													↓
`VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT`												↓
`VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT`											↓
`VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT`										↓
`VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT`									↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT`								↓
`VK_FORMAT_FEATURE_BLIT_DST_BIT`							↓
`VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT`						↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT`					↓
`VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT`				↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT`			↓
`VK_FORMAT_FEATURE_BLIT_SRC_BIT`		↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`	↓
Format	↓
`VK_FORMAT_ASTC_4x4_UNORM_BLOCK`	†	†	†
`VK_FORMAT_ASTC_4x4_SRGB_BLOCK`	†	†	†
`VK_FORMAT_ASTC_5x4_UNORM_BLOCK`	†	†	†
`VK_FORMAT_ASTC_5x4_SRGB_BLOCK`	†	†	†
`VK_FORMAT_ASTC_5x5_UNORM_BLOCK`	†	†	†
`VK_FORMAT_ASTC_5x5_SRGB_BLOCK`	†	†	†
`VK_FORMAT_ASTC_6x5_UNORM_BLOCK`	†	†	†
`VK_FORMAT_ASTC_6x5_SRGB_BLOCK`	†	†	†
`VK_FORMAT_ASTC_6x6_UNORM_BLOCK`	†	†	†
`VK_FORMAT_ASTC_6x6_SRGB_BLOCK`	†	†	†
`VK_FORMAT_ASTC_8x5_UNORM_BLOCK`	†	†	†
`VK_FORMAT_ASTC_8x5_SRGB_BLOCK`	†	†	†
`VK_FORMAT_ASTC_8x6_UNORM_BLOCK`	†	†	†
`VK_FORMAT_ASTC_8x6_SRGB_BLOCK`	†	†	†
`VK_FORMAT_ASTC_8x8_UNORM_BLOCK`	†	†	†
`VK_FORMAT_ASTC_8x8_SRGB_BLOCK`	†	†	†
`VK_FORMAT_ASTC_10x5_UNORM_BLOCK`	†	†	†
`VK_FORMAT_ASTC_10x5_SRGB_BLOCK`	†	†	†
`VK_FORMAT_ASTC_10x6_UNORM_BLOCK`	†	†	†
`VK_FORMAT_ASTC_10x6_SRGB_BLOCK`	†	†	†
`VK_FORMAT_ASTC_10x8_UNORM_BLOCK`	†	†	†
`VK_FORMAT_ASTC_10x8_SRGB_BLOCK`	†	†	†
`VK_FORMAT_ASTC_10x10_UNORM_BLOCK`	†	†	†
`VK_FORMAT_ASTC_10x10_SRGB_BLOCK`	†	†	†
`VK_FORMAT_ASTC_12x10_UNORM_BLOCK`	†	†	†
`VK_FORMAT_ASTC_12x10_SRGB_BLOCK`	†	†	†
`VK_FORMAT_ASTC_12x12_UNORM_BLOCK`	†	†	†
`VK_FORMAT_ASTC_12x12_SRGB_BLOCK`	†	†	†
The `VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`, `VK_FORMAT_FEATURE_BLIT_SRC_BIT` and `VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT` features must be supported in `optimalTilingFeatures` for all the formats in at least one of: this table, Mandatory format support: BC compressed formats with `VkImageType` `VK_IMAGE_TYPE_2D` and `VK_IMAGE_TYPE_3D`, or Mandatory format support: ETC2 and EAC compressed formats with `VkImageType` `VK_IMAGE_TYPE_2D`.

If cubic filtering is supported, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT must be supported for the following image view types:

VK_IMAGE_VIEW_TYPE_2D
VK_IMAGE_VIEW_TYPE_2D_ARRAY

for the following formats:

VK_FORMAT_R4G4_UNORM_PACK8
VK_FORMAT_R4G4B4A4_UNORM_PACK16
VK_FORMAT_B4G4R4A4_UNORM_PACK16
VK_FORMAT_R5G6B5_UNORM_PACK16
VK_FORMAT_B5G6R5_UNORM_PACK16
VK_FORMAT_R5G5B5A1_UNORM_PACK16
VK_FORMAT_B5G5R5A1_UNORM_PACK16
VK_FORMAT_A1R5G5B5_UNORM_PACK16
VK_FORMAT_R8_UNORM
VK_FORMAT_R8_SNORM
VK_FORMAT_R8_SRGB
VK_FORMAT_R8G8_UNORM
VK_FORMAT_R8G8_SNORM
VK_FORMAT_R8G8_SRGB
VK_FORMAT_R8G8B8_UNORM
VK_FORMAT_R8G8B8_SNORM
VK_FORMAT_R8G8B8_SRGB
VK_FORMAT_B8G8R8_UNORM
VK_FORMAT_B8G8R8_SNORM
VK_FORMAT_B8G8R8_SRGB
VK_FORMAT_R8G8B8A8_UNORM
VK_FORMAT_R8G8B8A8_SNORM
VK_FORMAT_R8G8B8A8_SRGB
VK_FORMAT_B8G8R8A8_UNORM
VK_FORMAT_B8G8R8A8_SNORM
VK_FORMAT_B8G8R8A8_SRGB
VK_FORMAT_A8B8G8R8_UNORM_PACK32
VK_FORMAT_A8B8G8R8_SNORM_PACK32
VK_FORMAT_A8B8G8R8_SRGB_PACK32

If ETC compressed formats are supported, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT must be supported for the following image view types:

VK_IMAGE_VIEW_TYPE_2D
VK_IMAGE_VIEW_TYPE_2D_ARRAY

for the following additional formats:

VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK
VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK
VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK
VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK
VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK
VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK

If cubic filtering is supported for any other formats, the following image view types must be supported for those formats:

VK_IMAGE_VIEW_TYPE_2D
VK_IMAGE_VIEW_TYPE_2D_ARRAY

To be used with VkImageView with subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, sampler Y′C_BC_R conversion must be enabled for the following formats:

Table 69. Formats requiring sampler Y′C_BC_R conversion for `VK_IMAGE_ASPECT_COLOR_BIT` image views
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT`											↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT`										↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT`									↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT`								↓
`VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT`							↓
`VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT`						↓
`VK_FORMAT_FEATURE_TRANSFER_DST_BIT`					↓
`VK_FORMAT_FEATURE_TRANSFER_SRC_BIT`				↓
`VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`			↓
`VK_FORMAT_FEATURE_DISJOINT_BIT`		↓
Format	Planes	↓
`VK_FORMAT_G8B8G8R8_422_UNORM`	1
`VK_FORMAT_B8G8R8G8_422_UNORM`	1
`VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM`	3		✓	✓	✓	✓
`VK_FORMAT_G8_B8R8_2PLANE_420_UNORM`	2		✓	✓	✓	✓
`VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM`	3
`VK_FORMAT_G8_B8R8_2PLANE_422_UNORM`	2
`VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM`	3
`VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16`	1
`VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16`	1
`VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16`	1
`VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16`	3
`VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16`	2
`VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16`	3
`VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16`	2
`VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16`	3
`VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16`	1
`VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16`	1
`VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16`	1
`VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16`	3
`VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16`	2
`VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16`	3
`VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16`	2
`VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16`	3
`VK_FORMAT_G16B16G16R16_422_UNORM`	1
`VK_FORMAT_B16G16R16G16_422_UNORM`	1
`VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM`	3
`VK_FORMAT_G16_B16R16_2PLANE_420_UNORM`	2
`VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM`	3
`VK_FORMAT_G16_B16R16_2PLANE_422_UNORM`	2
`VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM`	3
Format features marked ✓ must be supported only if VkPhysicalDeviceSamplerYcbcrConversionFeatures is enabled, and only with VkImageType `VK_IMAGE_TYPE_2D`

Implementations are not required to support the VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT VkImageCreateFlags for the above formats that require sampler Y′C_BC_R conversion. To determine whether the implementation supports sparse image creation flags with these formats use vkGetPhysicalDeviceImageFormatProperties or vkGetPhysicalDeviceImageFormatProperties2.

VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT must be supported for the following formats if the fragment density map feature is enabled:

VK_FORMAT_R8G8_UNORM

38. Additional Capabilities

This chapter describes additional capabilities beyond the minimum capabilities described in the (Limits and Formats chapters, including:

Additional Image Capabilities
Additional Buffer Capabilities
Optional Semaphore Capabilities
Optional Fence Capabilities
Timestamp Calibration Capabilities

38.1. Additional Image Capabilities

Additional image capabilities, such as larger dimensions or additional sample counts for certain image types, or additional capabilities for linear tiling format images, are described in this section.

To query additional capabilities specific to image types, call:

VkResult vkGetPhysicalDeviceImageFormatProperties(
    VkPhysicalDevice                            physicalDevice,
    VkFormat                                    format,
    VkImageType                                 type,
    VkImageTiling                               tiling,
    VkImageUsageFlags                           usage,
    VkImageCreateFlags                          flags,
    VkImageFormatProperties*                    pImageFormatProperties);

physicalDevice is the physical device from which to query the image capabilities.
format is a VkFormat value specifying the image format, corresponding to VkImageCreateInfo::format.
type is a VkImageType value specifying the image type, corresponding to VkImageCreateInfo::imageType.
tiling is a VkImageTiling value specifying the image tiling, corresponding to VkImageCreateInfo::tiling.
usage is a bitmask of VkImageUsageFlagBits specifying the intended usage of the image, corresponding to VkImageCreateInfo::usage.
flags is a bitmask of VkImageCreateFlagBits specifying additional parameters of the image, corresponding to VkImageCreateInfo::flags.
pImageFormatProperties is a pointer to a VkImageFormatProperties structure in which capabilities are returned.

The format, type, tiling, usage, and flags parameters correspond to parameters that would be consumed by vkCreateImage (as members of VkImageCreateInfo).

If format is not a supported image format, or if the combination of format, type, tiling, usage, and flags is not supported for images, then vkGetPhysicalDeviceImageFormatProperties returns VK_ERROR_FORMAT_NOT_SUPPORTED.

The limitations on an image format that are reported by vkGetPhysicalDeviceImageFormatProperties have the following property: if usage1 and usage2 of type VkImageUsageFlags are such that the bits set in usage1 are a subset of the bits set in usage2, and flags1 and flags2 of type VkImageCreateFlags are such that the bits set in flags1 are a subset of the bits set in flags2, then the limitations for usage1 and flags1 must be no more strict than the limitations for usage2 and flags2, for all values of format, type, and tiling.

Valid Usage

VUID-vkGetPhysicalDeviceImageFormatProperties-tiling-02248
tiling must not be VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT. (Use vkGetPhysicalDeviceImageFormatProperties2 instead).

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceImageFormatProperties-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceImageFormatProperties-format-parameter
format must be a valid VkFormat value
VUID-vkGetPhysicalDeviceImageFormatProperties-type-parameter
type must be a valid VkImageType value
VUID-vkGetPhysicalDeviceImageFormatProperties-tiling-parameter
tiling must be a valid VkImageTiling value
VUID-vkGetPhysicalDeviceImageFormatProperties-usage-parameter
usage must be a valid combination of VkImageUsageFlagBits values
VUID-vkGetPhysicalDeviceImageFormatProperties-usage-requiredbitmask
usage must not be 0
VUID-vkGetPhysicalDeviceImageFormatProperties-flags-parameter
flags must be a valid combination of VkImageCreateFlagBits values
VUID-vkGetPhysicalDeviceImageFormatProperties-pImageFormatProperties-parameter
pImageFormatProperties must be a valid pointer to a VkImageFormatProperties structure

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_FORMAT_NOT_SUPPORTED

The VkImageFormatProperties structure is defined as:

typedef struct VkImageFormatProperties {
    VkExtent3D            maxExtent;
    uint32_t              maxMipLevels;
    uint32_t              maxArrayLayers;
    VkSampleCountFlags    sampleCounts;
    VkDeviceSize          maxResourceSize;
} VkImageFormatProperties;

maxExtent are the maximum image dimensions. See the Allowed Extent Values section below for how these values are constrained by type.
maxMipLevels is the maximum number of mipmap levels. maxMipLevels must be equal to the number of levels in the complete mipmap chain based on the maxExtent.width, maxExtent.height, and maxExtent.depth, except when one of the following conditions is true, in which case it may instead be 1:
- vkGetPhysicalDeviceImageFormatProperties::tiling was VK_IMAGE_TILING_LINEAR
- VkPhysicalDeviceImageFormatInfo2::tiling was VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT
- the VkPhysicalDeviceImageFormatInfo2::pNext chain included a VkPhysicalDeviceExternalImageFormatInfo structure with a handle type included in the handleTypes member for which mipmap image support is not required
- image format is one of those listed in Formats requiring sampler Y′C_BC_R conversion for VK_IMAGE_ASPECT_COLOR_BIT image views
- flags contains VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT
maxArrayLayers is the maximum number of array layers. maxArrayLayers must be no less than VkPhysicalDeviceLimits::maxImageArrayLayers, except when one of the following conditions is true, in which case it may instead be 1:
- tiling is VK_IMAGE_TILING_LINEAR
- tiling is VK_IMAGE_TILING_OPTIMAL and type is VK_IMAGE_TYPE_3D
- format is one of those listed in Formats requiring sampler Y′C_BC_R conversion for VK_IMAGE_ASPECT_COLOR_BIT image views
If tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then maxArrayLayers must not be 0.
sampleCounts is a bitmask of VkSampleCountFlagBits specifying all the supported sample counts for this image as described below.
maxResourceSize is an upper bound on the total image size in bytes, inclusive of all image subresources. Implementations may have an address space limit on total size of a resource, which is advertised by this property. maxResourceSize must be at least 2³¹.

Note

There is no mechanism to query the size of an image before creating it, to compare that size against maxResourceSize. If an application attempts to create an image that exceeds this limit, the creation will fail and vkCreateImage will return VK_ERROR_OUT_OF_DEVICE_MEMORY. While the advertised limit must be at least 2³¹, it may not be possible to create an image that approaches that size, particularly for VK_IMAGE_TYPE_1D.

If the combination of parameters to vkGetPhysicalDeviceImageFormatProperties is not supported by the implementation for use in vkCreateImage, then all members of VkImageFormatProperties will be filled with zero.

Note

Filling VkImageFormatProperties with zero for unsupported formats is an exception to the usual rule that output structures have undefined contents on error. This exception was unintentional, but is preserved for backwards compatibility.

To determine the image capabilities compatible with an external memory handle type, call:

VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
    VkPhysicalDevice                            physicalDevice,
    VkFormat                                    format,
    VkImageType                                 type,
    VkImageTiling                               tiling,
    VkImageUsageFlags                           usage,
    VkImageCreateFlags                          flags,
    VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
    VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties);

physicalDevice is the physical device from which to query the image capabilities
format is the image format, corresponding to VkImageCreateInfo::format.
type is the image type, corresponding to VkImageCreateInfo::imageType.
tiling is the image tiling, corresponding to VkImageCreateInfo::tiling.
usage is the intended usage of the image, corresponding to VkImageCreateInfo::usage.
flags is a bitmask describing additional parameters of the image, corresponding to VkImageCreateInfo::flags.
externalHandleType is either one of the bits from VkExternalMemoryHandleTypeFlagBitsNV, or 0.
pExternalImageFormatProperties is a pointer to a VkExternalImageFormatPropertiesNV structure in which capabilities are returned.

If externalHandleType is 0, pExternalImageFormatProperties->imageFormatProperties will return the same values as a call to vkGetPhysicalDeviceImageFormatProperties, and the other members of pExternalImageFormatProperties will all be 0. Otherwise, they are filled in as described for VkExternalImageFormatPropertiesNV.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-format-parameter
format must be a valid VkFormat value
VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-type-parameter
type must be a valid VkImageType value
VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-tiling-parameter
tiling must be a valid VkImageTiling value
VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-parameter
usage must be a valid combination of VkImageUsageFlagBits values
VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-requiredbitmask
usage must not be 0
VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-flags-parameter
flags must be a valid combination of VkImageCreateFlagBits values
VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-externalHandleType-parameter
externalHandleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values
VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-pExternalImageFormatProperties-parameter
pExternalImageFormatProperties must be a valid pointer to a VkExternalImageFormatPropertiesNV structure

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_FORMAT_NOT_SUPPORTED

The VkExternalImageFormatPropertiesNV structure is defined as:

typedef struct VkExternalImageFormatPropertiesNV {
    VkImageFormatProperties              imageFormatProperties;
    VkExternalMemoryFeatureFlagsNV       externalMemoryFeatures;
    VkExternalMemoryHandleTypeFlagsNV    exportFromImportedHandleTypes;
    VkExternalMemoryHandleTypeFlagsNV    compatibleHandleTypes;
} VkExternalImageFormatPropertiesNV;

imageFormatProperties will be filled in as when calling vkGetPhysicalDeviceImageFormatProperties, but the values returned may vary depending on the external handle type requested.
externalMemoryFeatures is a bitmask of VkExternalMemoryFeatureFlagBitsNV, indicating properties of the external memory handle type (vkGetPhysicalDeviceExternalImageFormatPropertiesNV::externalHandleType) being queried, or 0 if the external memory handle type is 0.
exportFromImportedHandleTypes is a bitmask of VkExternalMemoryHandleTypeFlagBitsNV containing a bit set for every external handle type that may be used to create memory from which the handles of the type specified in vkGetPhysicalDeviceExternalImageFormatPropertiesNV::externalHandleType can be exported, or 0 if the external memory handle type is 0.
compatibleHandleTypes is a bitmask of VkExternalMemoryHandleTypeFlagBitsNV containing a bit set for every external handle type that may be specified simultaneously with the handle type specified by vkGetPhysicalDeviceExternalImageFormatPropertiesNV::externalHandleType when calling vkAllocateMemory, or 0 if the external memory handle type is 0. compatibleHandleTypes will always contain vkGetPhysicalDeviceExternalImageFormatPropertiesNV::externalHandleType

Bits which can be set in VkExternalImageFormatPropertiesNV::externalMemoryFeatures, indicating properties of the external memory handle type, are:

typedef enum VkExternalMemoryFeatureFlagBitsNV {
    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001,
    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002,
    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004,
    VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
} VkExternalMemoryFeatureFlagBitsNV;

VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV specifies that external memory of the specified type must be created as a dedicated allocation when used in the manner specified.
VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV specifies that the implementation supports exporting handles of the specified type.
VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV specifies that the implementation supports importing handles of the specified type.

typedef VkFlags VkExternalMemoryFeatureFlagsNV;

VkExternalMemoryFeatureFlagsNV is a bitmask type for setting a mask of zero or more VkExternalMemoryFeatureFlagBitsNV.

To query additional capabilities specific to image types, call:

VkResult vkGetPhysicalDeviceImageFormatProperties2(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
    VkImageFormatProperties2*                   pImageFormatProperties);

or the equivalent command

VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
    VkImageFormatProperties2*                   pImageFormatProperties);

physicalDevice is the physical device from which to query the image capabilities.
pImageFormatInfo is a pointer to a VkPhysicalDeviceImageFormatInfo2 structure describing the parameters that would be consumed by vkCreateImage.
pImageFormatProperties is a pointer to a VkImageFormatProperties2 structure in which capabilities are returned.

vkGetPhysicalDeviceImageFormatProperties2 behaves similarly to vkGetPhysicalDeviceImageFormatProperties, with the ability to return extended information in a pNext chain of output structures.

Valid Usage

VUID-vkGetPhysicalDeviceImageFormatProperties2-pNext-01868
If the pNext chain of pImageFormatProperties includes a VkAndroidHardwareBufferUsageANDROID structure, the pNext chain of pImageFormatInfo must include a VkPhysicalDeviceExternalImageFormatInfo structure with handleType set to VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceImageFormatProperties2-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatInfo-parameter
pImageFormatInfo must be a valid pointer to a valid VkPhysicalDeviceImageFormatInfo2 structure
VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatProperties-parameter
pImageFormatProperties must be a valid pointer to a VkImageFormatProperties2 structure

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_FORMAT_NOT_SUPPORTED

The VkPhysicalDeviceImageFormatInfo2 structure is defined as:

typedef struct VkPhysicalDeviceImageFormatInfo2 {
    VkStructureType       sType;
    const void*           pNext;
    VkFormat              format;
    VkImageType           type;
    VkImageTiling         tiling;
    VkImageUsageFlags     usage;
    VkImageCreateFlags    flags;
} VkPhysicalDeviceImageFormatInfo2;

or the equivalent

typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure. The pNext chain of VkPhysicalDeviceImageFormatInfo2 is used to provide additional image parameters to vkGetPhysicalDeviceImageFormatProperties2.
format is a VkFormat value indicating the image format, corresponding to VkImageCreateInfo::format.
type is a VkImageType value indicating the image type, corresponding to VkImageCreateInfo::imageType.
tiling is a VkImageTiling value indicating the image tiling, corresponding to VkImageCreateInfo::tiling.
usage is a bitmask of VkImageUsageFlagBits indicating the intended usage of the image, corresponding to VkImageCreateInfo::usage.
flags is a bitmask of VkImageCreateFlagBits indicating additional parameters of the image, corresponding to VkImageCreateInfo::flags.

The members of VkPhysicalDeviceImageFormatInfo2 correspond to the arguments to vkGetPhysicalDeviceImageFormatProperties, with sType and pNext added for extensibility.

Valid Usage

VUID-VkPhysicalDeviceImageFormatInfo2-tiling-02249
tiling must be VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT if and only if the pNext chain includes VkPhysicalDeviceImageDrmFormatModifierInfoEXT.
VUID-VkPhysicalDeviceImageFormatInfo2-tiling-02313
If tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT and flags contains VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, then the pNext chain must include a VkImageFormatListCreateInfo structure with non-zero viewFormatCount.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceImageFormatInfo2-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2
VUID-VkPhysicalDeviceImageFormatInfo2-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkPhysicalDeviceExternalImageFormatInfo, VkPhysicalDeviceImageDrmFormatModifierInfoEXT, or VkPhysicalDeviceImageViewImageFormatInfoEXT
VUID-VkPhysicalDeviceImageFormatInfo2-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkPhysicalDeviceImageFormatInfo2-format-parameter
format must be a valid VkFormat value
VUID-VkPhysicalDeviceImageFormatInfo2-type-parameter
type must be a valid VkImageType value
VUID-VkPhysicalDeviceImageFormatInfo2-tiling-parameter
tiling must be a valid VkImageTiling value
VUID-VkPhysicalDeviceImageFormatInfo2-usage-parameter
usage must be a valid combination of VkImageUsageFlagBits values
VUID-VkPhysicalDeviceImageFormatInfo2-usage-requiredbitmask
usage must not be 0
VUID-VkPhysicalDeviceImageFormatInfo2-flags-parameter
flags must be a valid combination of VkImageCreateFlagBits values

The VkImageFormatProperties2 structure is defined as:

typedef struct VkImageFormatProperties2 {
    VkStructureType            sType;
    void*                      pNext;
    VkImageFormatProperties    imageFormatProperties;
} VkImageFormatProperties2;

or the equivalent

typedef VkImageFormatProperties2 VkImageFormatProperties2KHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure. The pNext chain of VkImageFormatProperties2 is used to allow the specification of additional capabilities to be returned from vkGetPhysicalDeviceImageFormatProperties2.
imageFormatProperties is a VkImageFormatProperties structure in which capabilities are returned.

If the combination of parameters to vkGetPhysicalDeviceImageFormatProperties2 is not supported by the implementation for use in vkCreateImage, then all members of imageFormatProperties will be filled with zero.

Note

Filling imageFormatProperties with zero for unsupported formats is an exception to the usual rule that output structures have undefined contents on error. This exception was unintentional, but is preserved for backwards compatibility. This exeption only applies to imageFormatProperties, not sType, pNext, or any structures chained from pNext.

Valid Usage (Implicit)

VUID-VkImageFormatProperties2-sType-sType
sType must be VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2
VUID-VkImageFormatProperties2-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkAndroidHardwareBufferUsageANDROID, VkExternalImageFormatProperties, VkFilterCubicImageViewImageFormatPropertiesEXT, VkSamplerYcbcrConversionImageFormatProperties, or VkTextureLODGatherFormatPropertiesAMD
VUID-VkImageFormatProperties2-sType-unique
The sType value of each struct in the pNext chain must be unique

To determine if texture gather functions that take explicit LOD and/or bias argument values can be used with a given image format, add a VkImageFormatProperties2 structure to the pNext chain of the VkPhysicalDeviceImageFormatInfo2 structure and a VkTextureLODGatherFormatPropertiesAMD structure to the pNext chain of the VkImageFormatProperties2 structure.

The VkTextureLODGatherFormatPropertiesAMD structure is defined as:

typedef struct VkTextureLODGatherFormatPropertiesAMD {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           supportsTextureGatherLODBiasAMD;
} VkTextureLODGatherFormatPropertiesAMD;

sType is the type of this structure.
pNext is NULL.
supportsTextureGatherLODBiasAMD tells if the image format can be used with texture gather bias/LOD functions, as introduced by the VK_AMD_texture_gather_bias_lod extension. This field is set by the implementation. User-specified value is ignored.

Valid Usage (Implicit)

VUID-VkTextureLODGatherFormatPropertiesAMD-sType-sType
sType must be VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD

To determine the image capabilities compatible with an external memory handle type, add a VkPhysicalDeviceExternalImageFormatInfo structure to the pNext chain of the VkPhysicalDeviceImageFormatInfo2 structure and a VkExternalImageFormatProperties structure to the pNext chain of the VkImageFormatProperties2 structure.

The VkPhysicalDeviceExternalImageFormatInfo structure is defined as:

typedef struct VkPhysicalDeviceExternalImageFormatInfo {
    VkStructureType                       sType;
    const void*                           pNext;
    VkExternalMemoryHandleTypeFlagBits    handleType;
} VkPhysicalDeviceExternalImageFormatInfo;

or the equivalent

typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
handleType is a VkExternalMemoryHandleTypeFlagBits value specifying the memory handle type that will be used with the memory associated with the image.

If handleType is 0, vkGetPhysicalDeviceImageFormatProperties2 will behave as if VkPhysicalDeviceExternalImageFormatInfo was not present, and VkExternalImageFormatProperties will be ignored.

If handleType is not compatible with the format, type, tiling, usage, and flags specified in VkPhysicalDeviceImageFormatInfo2, then vkGetPhysicalDeviceImageFormatProperties2 returns VK_ERROR_FORMAT_NOT_SUPPORTED.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceExternalImageFormatInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO
VUID-VkPhysicalDeviceExternalImageFormatInfo-handleType-parameter
If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value

Possible values of VkPhysicalDeviceExternalImageFormatInfo::handleType, specifying an external memory handle type, are:

typedef enum VkExternalMemoryHandleTypeFlagBits {
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkExternalMemoryHandleTypeFlagBits;

or the equivalent

typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR;

VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT specifies a POSIX file descriptor handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the POSIX system calls dup, dup2, close, and the non-standard system call dup3. Additionally, it must be transportable over a socket using an SCM_RIGHTS control message. It owns a reference to the underlying memory resource represented by its Vulkan memory object.
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT specifies an NT handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the functions DuplicateHandle, CloseHandle, CompareObjectHandles, GetHandleInformation, and SetHandleInformation. It owns a reference to the underlying memory resource represented by its Vulkan memory object.
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT specifies a global share handle that has only limited valid usage outside of Vulkan and other compatible APIs. It is not compatible with any native APIs. It does not own a reference to the underlying memory resource represented its Vulkan memory object, and will therefore become invalid when all Vulkan memory objects associated with it are destroyed.
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT specifies an NT handle returned by IDXGIResource1::CreateSharedHandle referring to a Direct3D 10 or 11 texture resource. It owns a reference to the memory used by the Direct3D resource.
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT specifies a global share handle returned by IDXGIResource::GetSharedHandle referring to a Direct3D 10 or 11 texture resource. It does not own a reference to the underlying Direct3D resource, and will therefore become invalid when all Vulkan memory objects and Direct3D resources associated with it are destroyed.
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT specifies an NT handle returned by ID3D12Device::CreateSharedHandle referring to a Direct3D 12 heap resource. It owns a reference to the resources used by the Direct3D heap.
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT specifies an NT handle returned by ID3D12Device::CreateSharedHandle referring to a Direct3D 12 committed resource. It owns a reference to the memory used by the Direct3D resource.
VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT specifies a host pointer returned by a host memory allocation command. It does not own a reference to the underlying memory resource, and will therefore become invalid if the host memory is freed.
VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT specifies a host pointer to host mapped foreign memory. It does not own a reference to the underlying memory resource, and will therefore become invalid if the foreign memory is unmapped or otherwise becomes no longer available.
VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT is a file descriptor for a Linux dma_buf. It owns a reference to the underlying memory resource represented by its Vulkan memory object.
VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID specifies an AHardwareBuffer object defined by the Android NDK. See Android Hardware Buffers for more details of this handle type.

Some external memory handle types can only be shared within the same underlying physical device and/or the same driver version, as defined in the following table:

Table 70. External memory handle types compatibility
Handle type	`VkPhysicalDeviceIDProperties`::`driverUUID`	`VkPhysicalDeviceIDProperties`::`deviceUUID`
`VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT`	Must match	Must match
`VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT`	Must match	Must match
`VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT`	Must match	Must match
`VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT`	Must match	Must match
`VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT`	Must match	Must match
`VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT`	Must match	Must match
`VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT`	Must match	Must match
`VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT`	No restriction	No restriction
`VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT`	No restriction	No restriction
`VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT`	No restriction	No restriction
`VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID`	No restriction	No restriction

Note

The above table does not restrict the drivers and devices with which VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT and VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT may be shared, as these handle types inherently mean memory that does not come from the same device, as they import memory from the host or a foreign device, respectively.

Note

Even though the above table does not restrict the drivers and devices with which VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT may be shared, query mechanisms exist in the Vulkan API that prevent the import of incompatible dma-bufs (such as vkGetMemoryFdPropertiesKHR) and that prevent incompatible usage of dma-bufs (such as VkPhysicalDeviceExternalBufferInfo and VkPhysicalDeviceExternalImageFormatInfo).

typedef VkFlags VkExternalMemoryHandleTypeFlags;

or the equivalent

typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR;

VkExternalMemoryHandleTypeFlags is a bitmask type for setting a mask of zero or more VkExternalMemoryHandleTypeFlagBits.

The VkExternalImageFormatProperties structure is defined as:

typedef struct VkExternalImageFormatProperties {
    VkStructureType               sType;
    void*                         pNext;
    VkExternalMemoryProperties    externalMemoryProperties;
} VkExternalImageFormatProperties;

or the equivalent

typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
externalMemoryProperties is a VkExternalMemoryProperties structure specifying various capabilities of the external handle type when used with the specified image creation parameters.

Valid Usage (Implicit)

VUID-VkExternalImageFormatProperties-sType-sType
sType must be VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES

The VkExternalMemoryProperties structure is defined as:

typedef struct VkExternalMemoryProperties {
    VkExternalMemoryFeatureFlags       externalMemoryFeatures;
    VkExternalMemoryHandleTypeFlags    exportFromImportedHandleTypes;
    VkExternalMemoryHandleTypeFlags    compatibleHandleTypes;
} VkExternalMemoryProperties;

or the equivalent

typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR;

externalMemoryFeatures is a bitmask of VkExternalMemoryFeatureFlagBits specifying the features of handleType.
exportFromImportedHandleTypes is a bitmask of VkExternalMemoryHandleTypeFlagBits specifying which types of imported handle handleType can be exported from.
compatibleHandleTypes is a bitmask of VkExternalMemoryHandleTypeFlagBits specifying handle types which can be specified at the same time as handleType when creating an image compatible with external memory.

compatibleHandleTypes must include at least handleType. Inclusion of a handle type in compatibleHandleTypes does not imply the values returned in VkImageFormatProperties2 will be the same when VkPhysicalDeviceExternalImageFormatInfo::handleType is set to that type. The application is responsible for querying the capabilities of all handle types intended for concurrent use in a single image and intersecting them to obtain the compatible set of capabilities.

Bits which may be set in VkExternalMemoryProperties::externalMemoryFeatures, specifying features of an external memory handle type, are:

typedef enum VkExternalMemoryFeatureFlagBits {
    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001,
    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002,
    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004,
    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,
    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,
    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
    VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkExternalMemoryFeatureFlagBits;

or the equivalent

typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR;

VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT specifies that images or buffers created with the specified parameters and handle type must use the mechanisms defined by VkMemoryDedicatedRequirements and VkMemoryDedicatedAllocateInfo to create (or import) a dedicated allocation for the image or buffer.
VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT specifies that handles of this type can be exported from Vulkan memory objects.
VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT specifies that handles of this type can be imported as Vulkan memory objects.

Because their semantics in external APIs roughly align with that of an image or buffer with a dedicated allocation in Vulkan, implementations are required to report VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT for the following external handle types:

VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT
VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID for images only

Implementations must not report VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT for buffers with external handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID. Implementations must not report VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT for images or buffers with external handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT.

typedef VkFlags VkExternalMemoryFeatureFlags;

or the equivalent

typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR;

VkExternalMemoryFeatureFlags is a bitmask type for setting a mask of zero or more VkExternalMemoryFeatureFlagBits.

To query the image capabilities that are compatible with a Linux DRM format modifier, set VkPhysicalDeviceImageFormatInfo2::tiling to VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT and add a VkPhysicalDeviceImageDrmFormatModifierInfoEXT structure to the pNext chain of VkPhysicalDeviceImageFormatInfo2.

The VkPhysicalDeviceImageDrmFormatModifierInfoEXT structure is defined as:

typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT {
    VkStructureType    sType;
    const void*        pNext;
    uint64_t           drmFormatModifier;
    VkSharingMode      sharingMode;
    uint32_t           queueFamilyIndexCount;
    const uint32_t*    pQueueFamilyIndices;
} VkPhysicalDeviceImageDrmFormatModifierInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
drmFormatModifier is the image’s Linux DRM format modifier, corresponding to VkImageDrmFormatModifierExplicitCreateInfoEXT::modifier or to VkImageDrmFormatModifierListCreateInfoEXT::pModifiers.
sharingMode specifies how the image will be accessed by multiple queue families.
queueFamilyIndexCount is the number of entries in the pQueueFamilyIndices array.
pQueueFamilyIndices is a list of queue families that will access the image (ignored if sharingMode is not VK_SHARING_MODE_CONCURRENT).

If the drmFormatModifier is incompatible with the parameters specified in VkPhysicalDeviceImageFormatInfo2 and its pNext chain, then vkGetPhysicalDeviceImageFormatProperties2 returns VK_ERROR_FORMAT_NOT_SUPPORTED. The implementation must support the query of any drmFormatModifier, including unknown and invalid modifier values.

Valid Usage

VUID-VkPhysicalDeviceImageDrmFormatModifierInfoEXT-sharingMode-02314
If sharingMode is VK_SHARING_MODE_CONCURRENT, then pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values.
VUID-VkPhysicalDeviceImageDrmFormatModifierInfoEXT-sharingMode-02315
If sharingMode is VK_SHARING_MODE_CONCURRENT, then queueFamilyIndexCount must be greater than 1.
VUID-VkPhysicalDeviceImageDrmFormatModifierInfoEXT-sharingMode-02316
If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than the pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceImageDrmFormatModifierInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT
VUID-VkPhysicalDeviceImageDrmFormatModifierInfoEXT-sharingMode-parameter
sharingMode must be a valid VkSharingMode value

To determine the number of combined image samplers required to support a multi-planar format, add VkSamplerYcbcrConversionImageFormatProperties to the pNext chain of the VkImageFormatProperties2 structure in a call to vkGetPhysicalDeviceImageFormatProperties2.

The VkSamplerYcbcrConversionImageFormatProperties structure is defined as:

typedef struct VkSamplerYcbcrConversionImageFormatProperties {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           combinedImageSamplerDescriptorCount;
} VkSamplerYcbcrConversionImageFormatProperties;

or the equivalent

typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
combinedImageSamplerDescriptorCount is the number of combined image sampler descriptors that the implementation uses to access the format.

Valid Usage (Implicit)

VUID-VkSamplerYcbcrConversionImageFormatProperties-sType-sType
sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES

combinedImageSamplerDescriptorCount is a number between 1 and the number of planes in the format. A descriptor set layout binding with immutable Y′C_BC_R conversion samplers will have a maximum combinedImageSamplerDescriptorCount which is the maximum across all formats supported by its samplers of the combinedImageSamplerDescriptorCount for each format. Descriptor sets with that layout will internally use that maximum combinedImageSamplerDescriptorCount descriptors for each descriptor in the binding. This expanded number of descriptors will be consumed from the descriptor pool when a descriptor set is allocated, and counts towards the maxDescriptorSetSamplers, maxDescriptorSetSampledImages, maxPerStageDescriptorSamplers, and maxPerStageDescriptorSampledImages limits.

Note

All descriptors in a binding use the same maximum combinedImageSamplerDescriptorCount descriptors to allow implementations to use a uniform stride for dynamic indexing of the descriptors in the binding.

For example, consider a descriptor set layout binding with two descriptors and immutable samplers for multi-planar formats that have VkSamplerYcbcrConversionImageFormatProperties::combinedImageSamplerDescriptorCount values of 2 and 3 respectively. There are two descriptors in the binding and the maximum combinedImageSamplerDescriptorCount is 3, so descriptor sets with this layout consume 6 descriptors from the descriptor pool. To create a descriptor pool that allows allocating four descriptor sets with this layout, descriptorCount must be at least 24.

To obtain optimal Android hardware buffer usage flags for specific image creation parameters, add a VkAndroidHardwareBufferUsageANDROID structure to the pNext chain of a VkImageFormatProperties2 structure passed to vkGetPhysicalDeviceImageFormatProperties2. This structure is defined as:

typedef struct VkAndroidHardwareBufferUsageANDROID {
    VkStructureType    sType;
    void*              pNext;
    uint64_t           androidHardwareBufferUsage;
} VkAndroidHardwareBufferUsageANDROID;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
androidHardwareBufferUsage returns the Android hardware buffer usage flags.

The androidHardwareBufferUsage field must include Android hardware buffer usage flags listed in the AHardwareBuffer Usage Equivalence table when the corresponding Vulkan image usage or image creation flags are included in the usage or flags fields of VkPhysicalDeviceImageFormatInfo2. It must include at least one GPU usage flag (AHARDWAREBUFFER_USAGE_GPU_*), even if none of the corresponding Vulkan usages or flags are requested.

Note

Requiring at least one GPU usage flag ensures that Android hardware buffer memory will be allocated in a memory pool accessible to the Vulkan implementation, and that specializing the memory layout based on usage flags does not prevent it from being compatible with Vulkan. Implementations may avoid unnecessary restrictions caused by this requirement by using vendor usage flags to indicate that only the Vulkan uses indicated in VkImageFormatProperties2 are required.

Valid Usage (Implicit)

VUID-VkAndroidHardwareBufferUsageANDROID-sType-sType
sType must be VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID

To determine if cubic filtering can be used with a given image format and a given image view type add a VkPhysicalDeviceImageViewImageFormatInfoEXT structure to the pNext chain of the VkPhysicalDeviceImageFormatInfo2 structure, and a VkFilterCubicImageViewImageFormatPropertiesEXT structure to the pNext chain of the VkImageFormatProperties2 structure.

The VkPhysicalDeviceImageViewImageFormatInfoEXT structure is defined as:

typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT {
    VkStructureType    sType;
    void*              pNext;
    VkImageViewType    imageViewType;
} VkPhysicalDeviceImageViewImageFormatInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
imageViewType is a VkImageViewType value specifying the type of the image view.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceImageViewImageFormatInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT
VUID-VkPhysicalDeviceImageViewImageFormatInfoEXT-imageViewType-parameter
imageViewType must be a valid VkImageViewType value

The VkFilterCubicImageViewImageFormatPropertiesEXT structure is defined as:

typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           filterCubic;
    VkBool32           filterCubicMinmax;
} VkFilterCubicImageViewImageFormatPropertiesEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
filterCubic tells if image format, image type and image view type can be used with cubic filtering. This field is set by the implementation. User-specified value is ignored.
filterCubicMinmax tells if image format, image type and image view type can be used with cubic filtering and minmax filtering. This field is set by the implementation. User-specified value is ignored.

Valid Usage (Implicit)

VUID-VkFilterCubicImageViewImageFormatPropertiesEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT

Valid Usage

VUID-VkFilterCubicImageViewImageFormatPropertiesEXT-pNext-02627
If the pNext chain of the VkImageFormatProperties2 structure includes a VkFilterCubicImageViewImageFormatPropertiesEXT structure, the pNext chain of the VkPhysicalDeviceImageFormatInfo2 structure must include a VkPhysicalDeviceImageViewImageFormatInfoEXT structure with an imageViewType that is compatible with imageType.

38.1.1. Supported Sample Counts

vkGetPhysicalDeviceImageFormatProperties returns a bitmask of VkSampleCountFlagBits in sampleCounts specifying the supported sample counts for the image parameters.

sampleCounts will be set to VK_SAMPLE_COUNT_1_BIT if at least one of the following conditions is true:

tiling is VK_IMAGE_TILING_LINEAR
type is not VK_IMAGE_TYPE_2D
flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT
Neither the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag nor the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties is set
VkPhysicalDeviceExternalImageFormatInfo::handleType is an external handle type for which multisampled image support is not required.
format is one of those listed in Formats requiring sampler Y′C_BC_R conversion for VK_IMAGE_ASPECT_COLOR_BIT image views
usage contains VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV
usage contains VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT

Otherwise, the bits set in sampleCounts will be the sample counts supported for the specified values of usage and format. For each bit set in usage, the supported sample counts relate to the limits in VkPhysicalDeviceLimits as follows:

If usage includes VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT and format is a floating- or fixed-point color format, a superset of VkPhysicalDeviceLimits::framebufferColorSampleCounts
If usage includes VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT and format is an integer format, a superset of VkPhysicalDeviceVulkan12Properties::framebufferIntegerColorSampleCounts
If usage includes VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, and format includes a depth aspect, a superset of VkPhysicalDeviceLimits::framebufferDepthSampleCounts
If usage includes VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, and format includes a stencil aspect, a superset of VkPhysicalDeviceLimits::framebufferStencilSampleCounts
If usage includes VK_IMAGE_USAGE_SAMPLED_BIT, and format includes a color aspect, a superset of VkPhysicalDeviceLimits::sampledImageColorSampleCounts
If usage includes VK_IMAGE_USAGE_SAMPLED_BIT, and format includes a depth aspect, a superset of VkPhysicalDeviceLimits::sampledImageDepthSampleCounts
If usage includes VK_IMAGE_USAGE_SAMPLED_BIT, and format is an integer format, a superset of VkPhysicalDeviceLimits::sampledImageIntegerSampleCounts
If usage includes VK_IMAGE_USAGE_STORAGE_BIT, a superset of VkPhysicalDeviceLimits::storageImageSampleCounts

If multiple bits are set in usage, sampleCounts will be the intersection of the per-usage values described above.

If none of the bits described above are set in usage, then there is no corresponding limit in VkPhysicalDeviceLimits. In this case, sampleCounts must include at least VK_SAMPLE_COUNT_1_BIT.

38.1.2. Allowed Extent Values Based On Image Type

Implementations may support extent values larger than the required minimum/maximum values for certain types of images subject to the constraints below.

Note

Implementations must support images with dimensions up to the required minimum/maximum values for all types of images. It follows that the query for additional capabilities must return extent values that are at least as large as the required values.

For VK_IMAGE_TYPE_1D:

maxExtent.width ≥ VkPhysicalDeviceLimits.maxImageDimension1D
maxExtent.height = 1
maxExtent.depth = 1

For VK_IMAGE_TYPE_2D when flags does not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT:

maxExtent.width ≥ VkPhysicalDeviceLimits.maxImageDimension2D
maxExtent.height ≥ VkPhysicalDeviceLimits.maxImageDimension2D
maxExtent.depth = 1

For VK_IMAGE_TYPE_2D when flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT:

maxExtent.width ≥ VkPhysicalDeviceLimits.maxImageDimensionCube
maxExtent.height ≥ VkPhysicalDeviceLimits.maxImageDimensionCube
maxExtent.depth = 1

For VK_IMAGE_TYPE_3D:

maxExtent.width ≥ VkPhysicalDeviceLimits.maxImageDimension3D
maxExtent.height ≥ VkPhysicalDeviceLimits.maxImageDimension3D
maxExtent.depth ≥ VkPhysicalDeviceLimits.maxImageDimension3D

38.2. Additional Buffer Capabilities

To query the external handle types supported by buffers, call:

void vkGetPhysicalDeviceExternalBufferProperties(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
    VkExternalBufferProperties*                 pExternalBufferProperties);

or the equivalent command

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

physicalDevice is the physical device from which to query the buffer capabilities.
pExternalBufferInfo is a pointer to a VkPhysicalDeviceExternalBufferInfo structure describing the parameters that would be consumed by vkCreateBuffer.
pExternalBufferProperties is a pointer to a VkExternalBufferProperties structure in which capabilities are returned.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceExternalBufferProperties-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferInfo-parameter
pExternalBufferInfo must be a valid pointer to a valid VkPhysicalDeviceExternalBufferInfo structure
VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferProperties-parameter
pExternalBufferProperties must be a valid pointer to a VkExternalBufferProperties structure

The VkPhysicalDeviceExternalBufferInfo structure is defined as:

typedef struct VkPhysicalDeviceExternalBufferInfo {
    VkStructureType                       sType;
    const void*                           pNext;
    VkBufferCreateFlags                   flags;
    VkBufferUsageFlags                    usage;
    VkExternalMemoryHandleTypeFlagBits    handleType;
} VkPhysicalDeviceExternalBufferInfo;

or the equivalent

typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR;

sType is the type of this structure
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkBufferCreateFlagBits describing additional parameters of the buffer, corresponding to VkBufferCreateInfo::flags.
usage is a bitmask of VkBufferUsageFlagBits describing the intended usage of the buffer, corresponding to VkBufferCreateInfo::usage.
handleType is a VkExternalMemoryHandleTypeFlagBits value specifying the memory handle type that will be used with the memory associated with the buffer.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceExternalBufferInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO
VUID-VkPhysicalDeviceExternalBufferInfo-pNext-pNext
pNext must be NULL
VUID-VkPhysicalDeviceExternalBufferInfo-flags-parameter
flags must be a valid combination of VkBufferCreateFlagBits values
VUID-VkPhysicalDeviceExternalBufferInfo-usage-parameter
usage must be a valid combination of VkBufferUsageFlagBits values
VUID-VkPhysicalDeviceExternalBufferInfo-usage-requiredbitmask
usage must not be 0
VUID-VkPhysicalDeviceExternalBufferInfo-handleType-parameter
handleType must be a valid VkExternalMemoryHandleTypeFlagBits value

The VkExternalBufferProperties structure is defined as:

typedef struct VkExternalBufferProperties {
    VkStructureType               sType;
    void*                         pNext;
    VkExternalMemoryProperties    externalMemoryProperties;
} VkExternalBufferProperties;

or the equivalent

typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR;

sType is the type of this structure
pNext is NULL or a pointer to an extension-specific structure.
externalMemoryProperties is a VkExternalMemoryProperties structure specifying various capabilities of the external handle type when used with the specified buffer creation parameters.

Valid Usage (Implicit)

VUID-VkExternalBufferProperties-sType-sType
sType must be VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES
VUID-VkExternalBufferProperties-pNext-pNext
pNext must be NULL

38.3. Optional Semaphore Capabilities

Semaphores may support import and export of their payload to external handles. To query the external handle types supported by semaphores, call:

void vkGetPhysicalDeviceExternalSemaphoreProperties(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
    VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);

or the equivalent command

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

physicalDevice is the physical device from which to query the semaphore capabilities.
pExternalSemaphoreInfo is a pointer to a VkPhysicalDeviceExternalSemaphoreInfo structure describing the parameters that would be consumed by vkCreateSemaphore.
pExternalSemaphoreProperties is a pointer to a VkExternalSemaphoreProperties structure in which capabilities are returned.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreInfo-parameter
pExternalSemaphoreInfo must be a valid pointer to a valid VkPhysicalDeviceExternalSemaphoreInfo structure
VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreProperties-parameter
pExternalSemaphoreProperties must be a valid pointer to a VkExternalSemaphoreProperties structure

The VkPhysicalDeviceExternalSemaphoreInfo structure is defined as:

typedef struct VkPhysicalDeviceExternalSemaphoreInfo {
    VkStructureType                          sType;
    const void*                              pNext;
    VkExternalSemaphoreHandleTypeFlagBits    handleType;
} VkPhysicalDeviceExternalSemaphoreInfo;

or the equivalent

typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR;

sType is the type of this structure
pNext is NULL or a pointer to an extension-specific structure.
handleType is a VkExternalSemaphoreHandleTypeFlagBits value specifying the external semaphore handle type for which capabilities will be returned.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceExternalSemaphoreInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO
VUID-VkPhysicalDeviceExternalSemaphoreInfo-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkSemaphoreTypeCreateInfo
VUID-VkPhysicalDeviceExternalSemaphoreInfo-sType-unique
The sType value of each struct in the pNext chain must be unique
VUID-VkPhysicalDeviceExternalSemaphoreInfo-handleType-parameter
handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value

Bits which may be set in VkPhysicalDeviceExternalSemaphoreInfo::handleType, specifying an external semaphore handle type, are:

typedef enum VkExternalSemaphoreHandleTypeFlagBits {
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008,
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010,
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkExternalSemaphoreHandleTypeFlagBits;

or the equivalent

typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR;

VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT specifies a POSIX file descriptor handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the POSIX system calls dup, dup2, close, and the non-standard system call dup3. Additionally, it must be transportable over a socket using an SCM_RIGHTS control message. It owns a reference to the underlying synchronization primitive represented by its Vulkan semaphore object.
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT specifies an NT handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the functions DuplicateHandle, CloseHandle, CompareObjectHandles, GetHandleInformation, and SetHandleInformation. It owns a reference to the underlying synchronization primitive represented by its Vulkan semaphore object.
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT specifies a global share handle that has only limited valid usage outside of Vulkan and other compatible APIs. It is not compatible with any native APIs. It does not own a reference to the underlying synchronization primitive represented its Vulkan semaphore object, and will therefore become invalid when all Vulkan semaphore objects associated with it are destroyed.
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT specifies an NT handle returned by ID3D12Device::CreateSharedHandle referring to a Direct3D 12 fence. It owns a reference to the underlying synchronization primitive associated with the Direct3D fence.
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT specifies a POSIX file descriptor handle to a Linux Sync File or Android Fence object. It can be used with any native API accepting a valid sync file or fence as input. It owns a reference to the underlying synchronization primitive associated with the file descriptor. Implementations which support importing this handle type must accept any type of sync or fence FD supported by the native system they are running on.

Note

Handles of type VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT generated by the implementation may represent either Linux Sync Files or Android Fences at the implementation’s discretion. Applications should only use operations defined for both types of file descriptors, unless they know via means external to Vulkan the type of the file descriptor, or are prepared to deal with the system-defined operation failures resulting from using the wrong type.

Some external semaphore handle types can only be shared within the same underlying physical device and/or the same driver version, as defined in the following table:

Table 71. External semaphore handle types compatibility
Handle type	`VkPhysicalDeviceIDProperties`::`driverUUID`	`VkPhysicalDeviceIDProperties`::`deviceUUID`
`VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT`	Must match	Must match
`VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT`	Must match	Must match
`VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT`	Must match	Must match
`VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT`	Must match	Must match
`VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT`	No restriction	No restriction

typedef VkFlags VkExternalSemaphoreHandleTypeFlags;

or the equivalent

typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR;

VkExternalSemaphoreHandleTypeFlags is a bitmask type for setting a mask of zero or more VkExternalSemaphoreHandleTypeFlagBits.

The VkExternalSemaphoreProperties structure is defined as:

typedef struct VkExternalSemaphoreProperties {
    VkStructureType                       sType;
    void*                                 pNext;
    VkExternalSemaphoreHandleTypeFlags    exportFromImportedHandleTypes;
    VkExternalSemaphoreHandleTypeFlags    compatibleHandleTypes;
    VkExternalSemaphoreFeatureFlags       externalSemaphoreFeatures;
} VkExternalSemaphoreProperties;

or the equivalent

typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR;

exportFromImportedHandleTypes is a bitmask of VkExternalSemaphoreHandleTypeFlagBits specifying which types of imported handle handleType can be exported from.
compatibleHandleTypes is a bitmask of VkExternalSemaphoreHandleTypeFlagBits specifying handle types which can be specified at the same time as handleType when creating a semaphore.
externalSemaphoreFeatures is a bitmask of VkExternalSemaphoreFeatureFlagBits describing the features of handleType.

If handleType is not supported by the implementation, then VkExternalSemaphoreProperties::externalSemaphoreFeatures will be set to zero.

Valid Usage (Implicit)

VUID-VkExternalSemaphoreProperties-sType-sType
sType must be VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES
VUID-VkExternalSemaphoreProperties-pNext-pNext
pNext must be NULL

Possible values of VkExternalSemaphoreProperties::externalSemaphoreFeatures, specifying the features of an external semaphore handle type, are:

typedef enum VkExternalSemaphoreFeatureFlagBits {
    VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001,
    VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002,
    VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,
    VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT,
    VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkExternalSemaphoreFeatureFlagBits;

or the equivalent

typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR;

VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT specifies that handles of this type can be exported from Vulkan semaphore objects.
VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT specifies that handles of this type can be imported as Vulkan semaphore objects.

typedef VkFlags VkExternalSemaphoreFeatureFlags;

or the equivalent

typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR;

VkExternalSemaphoreFeatureFlags is a bitmask type for setting a mask of zero or more VkExternalSemaphoreFeatureFlagBits.

38.4. Optional Fence Capabilities

Fences may support import and export of their payload to external handles. To query the external handle types supported by fences, call:

void vkGetPhysicalDeviceExternalFenceProperties(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
    VkExternalFenceProperties*                  pExternalFenceProperties);

or the equivalent command

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

physicalDevice is the physical device from which to query the fence capabilities.
pExternalFenceInfo is a pointer to a VkPhysicalDeviceExternalFenceInfo structure describing the parameters that would be consumed by vkCreateFence.
pExternalFenceProperties is a pointer to a VkExternalFenceProperties structure in which capabilities are returned.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceExternalFenceProperties-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceInfo-parameter
pExternalFenceInfo must be a valid pointer to a valid VkPhysicalDeviceExternalFenceInfo structure
VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceProperties-parameter
pExternalFenceProperties must be a valid pointer to a VkExternalFenceProperties structure

The VkPhysicalDeviceExternalFenceInfo structure is defined as:

typedef struct VkPhysicalDeviceExternalFenceInfo {
    VkStructureType                      sType;
    const void*                          pNext;
    VkExternalFenceHandleTypeFlagBits    handleType;
} VkPhysicalDeviceExternalFenceInfo;

or the equivalent

typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR;

sType is the type of this structure
pNext is NULL or a pointer to an extension-specific structure.
handleType is a VkExternalFenceHandleTypeFlagBits value indicating an external fence handle type for which capabilities will be returned.

Note

Handles of type VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT generated by the implementation may represent either Linux Sync Files or Android Fences at the implementation’s discretion. Applications should only use operations defined for both types of file descriptors, unless they know via means external to Vulkan the type of the file descriptor, or are prepared to deal with the system-defined operation failures resulting from using the wrong type.

Valid Usage (Implicit)

VUID-VkPhysicalDeviceExternalFenceInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO
VUID-VkPhysicalDeviceExternalFenceInfo-pNext-pNext
pNext must be NULL
VUID-VkPhysicalDeviceExternalFenceInfo-handleType-parameter
handleType must be a valid VkExternalFenceHandleTypeFlagBits value

Bits which may be set in VkPhysicalDeviceExternalFenceInfo::handleType, and in the exportFromImportedHandleTypes and compatibleHandleTypes members of VkExternalFenceProperties, to indicate external fence handle types, are:

typedef enum VkExternalFenceHandleTypeFlagBits {
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
    VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008,
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
    VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT,
    VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkExternalFenceHandleTypeFlagBits;

or the equivalent

typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR;

VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT specifies a POSIX file descriptor handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the POSIX system calls dup, dup2, close, and the non-standard system call dup3. Additionally, it must be transportable over a socket using an SCM_RIGHTS control message. It owns a reference to the underlying synchronization primitive represented by its Vulkan fence object.
VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT specifies an NT handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the functions DuplicateHandle, CloseHandle, CompareObjectHandles, GetHandleInformation, and SetHandleInformation. It owns a reference to the underlying synchronization primitive represented by its Vulkan fence object.
VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT specifies a global share handle that has only limited valid usage outside of Vulkan and other compatible APIs. It is not compatible with any native APIs. It does not own a reference to the underlying synchronization primitive represented by its Vulkan fence object, and will therefore become invalid when all Vulkan fence objects associated with it are destroyed.
VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT specifies a POSIX file descriptor handle to a Linux Sync File or Android Fence. It can be used with any native API accepting a valid sync file or fence as input. It owns a reference to the underlying synchronization primitive associated with the file descriptor. Implementations which support importing this handle type must accept any type of sync or fence FD supported by the native system they are running on.

Some external fence handle types can only be shared within the same underlying physical device and/or the same driver version, as defined in the following table:

Table 72. External fence handle types compatibility
Handle type	`VkPhysicalDeviceIDProperties`::`driverUUID`	`VkPhysicalDeviceIDProperties`::`deviceUUID`
`VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT`	Must match	Must match
`VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT`	Must match	Must match
`VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT`	Must match	Must match
`VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT`	No restriction	No restriction

typedef VkFlags VkExternalFenceHandleTypeFlags;

or the equivalent

typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR;

VkExternalFenceHandleTypeFlags is a bitmask type for setting a mask of zero or more VkExternalFenceHandleTypeFlagBits.

The VkExternalFenceProperties structure is defined as:

typedef struct VkExternalFenceProperties {
    VkStructureType                   sType;
    void*                             pNext;
    VkExternalFenceHandleTypeFlags    exportFromImportedHandleTypes;
    VkExternalFenceHandleTypeFlags    compatibleHandleTypes;
    VkExternalFenceFeatureFlags       externalFenceFeatures;
} VkExternalFenceProperties;

or the equivalent

typedef VkExternalFenceProperties VkExternalFencePropertiesKHR;

exportFromImportedHandleTypes is a bitmask of VkExternalFenceHandleTypeFlagBits indicating which types of imported handle handleType can be exported from.
compatibleHandleTypes is a bitmask of VkExternalFenceHandleTypeFlagBits specifying handle types which can be specified at the same time as handleType when creating a fence.
externalFenceFeatures is a bitmask of VkExternalFenceFeatureFlagBits indicating the features of handleType.

If handleType is not supported by the implementation, then VkExternalFenceProperties::externalFenceFeatures will be set to zero.

Valid Usage (Implicit)

VUID-VkExternalFenceProperties-sType-sType
sType must be VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES
VUID-VkExternalFenceProperties-pNext-pNext
pNext must be NULL

Bits which may be set in VkExternalFenceProperties::externalFenceFeatures, indicating features of a fence external handle type, are:

typedef enum VkExternalFenceFeatureFlagBits {
    VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001,
    VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002,
    VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,
    VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT,
    VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkExternalFenceFeatureFlagBits;

or the equivalent

typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR;

VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT specifies handles of this type can be exported from Vulkan fence objects.
VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT specifies handles of this type can be imported to Vulkan fence objects.

typedef VkFlags VkExternalFenceFeatureFlags;

or the equivalent

typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR;

VkExternalFenceFeatureFlags is a bitmask type for setting a mask of zero or more VkExternalFenceFeatureFlagBits.

38.5. Timestamp Calibration Capabilities

To query the set of time domains for which a physical device supports timestamp calibration, call:

VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pTimeDomainCount,
    VkTimeDomainEXT*                            pTimeDomains);

physicalDevice is the physical device from which to query the set of calibrateable time domains.
pTimeDomainCount is a pointer to an integer related to the number of calibrateable time domains available or queried, as described below.
pTimeDomains is either NULL or a pointer to an array of VkTimeDomainEXT values, indicating the supported calibrateable time domains.

If pTimeDomains is NULL, then the number of calibrateable time domains supported for the given physicalDevice is returned in pTimeDomainCount. Otherwise, pTimeDomainCount must point to a variable set by the user to the number of elements in the pTimeDomains array, and on return the variable is overwritten with the number of values actually written to pTimeDomains. If the value of pTimeDomainCount is less than the number of calibrateable time domains supported, at most pTimeDomainCount values will be written to pTimeDomains. If pTimeDomainCount is smaller than the number of calibrateable time domains supported for the given physicalDevice, VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceCalibrateableTimeDomainsEXT-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceCalibrateableTimeDomainsEXT-pTimeDomainCount-parameter
pTimeDomainCount must be a valid pointer to a uint32_t value
VUID-vkGetPhysicalDeviceCalibrateableTimeDomainsEXT-pTimeDomains-parameter
If the value referenced by pTimeDomainCount is not 0, and pTimeDomains is not NULL, pTimeDomains must be a valid pointer to an array of pTimeDomainCount VkTimeDomainEXT values

Return Codes

VK_SUCCESS
VK_INCOMPLETE

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

39. Debugging

To aid developers in tracking down errors in the application’s use of Vulkan, particularly in combination with an external debugger or profiler, debugging extensions may be available.

The VkObjectType enumeration defines values, each of which corresponds to a specific Vulkan handle type. These values can be used to associate debug information with a particular type of object through one or more extensions.

typedef enum VkObjectType {
    VK_OBJECT_TYPE_UNKNOWN = 0,
    VK_OBJECT_TYPE_INSTANCE = 1,
    VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2,
    VK_OBJECT_TYPE_DEVICE = 3,
    VK_OBJECT_TYPE_QUEUE = 4,
    VK_OBJECT_TYPE_SEMAPHORE = 5,
    VK_OBJECT_TYPE_COMMAND_BUFFER = 6,
    VK_OBJECT_TYPE_FENCE = 7,
    VK_OBJECT_TYPE_DEVICE_MEMORY = 8,
    VK_OBJECT_TYPE_BUFFER = 9,
    VK_OBJECT_TYPE_IMAGE = 10,
    VK_OBJECT_TYPE_EVENT = 11,
    VK_OBJECT_TYPE_QUERY_POOL = 12,
    VK_OBJECT_TYPE_BUFFER_VIEW = 13,
    VK_OBJECT_TYPE_IMAGE_VIEW = 14,
    VK_OBJECT_TYPE_SHADER_MODULE = 15,
    VK_OBJECT_TYPE_PIPELINE_CACHE = 16,
    VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17,
    VK_OBJECT_TYPE_RENDER_PASS = 18,
    VK_OBJECT_TYPE_PIPELINE = 19,
    VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20,
    VK_OBJECT_TYPE_SAMPLER = 21,
    VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22,
    VK_OBJECT_TYPE_DESCRIPTOR_SET = 23,
    VK_OBJECT_TYPE_FRAMEBUFFER = 24,
    VK_OBJECT_TYPE_COMMAND_POOL = 25,
    VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000,
    VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000,
    VK_OBJECT_TYPE_SURFACE_KHR = 1000000000,
    VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000,
    VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000,
    VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001,
    VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000,
    VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000,
    VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001,
    VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000,
    VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000,
    VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,
    VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000,
    VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
    VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
    VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkObjectType;

Table 73. VkObjectType and Vulkan Handle Relationship
VkObjectType	Vulkan Handle Type
`VK_OBJECT_TYPE_UNKNOWN`	Unknown/Undefined Handle
`VK_OBJECT_TYPE_INSTANCE`	VkInstance
`VK_OBJECT_TYPE_PHYSICAL_DEVICE`	VkPhysicalDevice
`VK_OBJECT_TYPE_DEVICE`	VkDevice
`VK_OBJECT_TYPE_QUEUE`	VkQueue
`VK_OBJECT_TYPE_SEMAPHORE`	VkSemaphore
`VK_OBJECT_TYPE_COMMAND_BUFFER`	VkCommandBuffer
`VK_OBJECT_TYPE_FENCE`	VkFence
`VK_OBJECT_TYPE_DEVICE_MEMORY`	VkDeviceMemory
`VK_OBJECT_TYPE_BUFFER`	VkBuffer
`VK_OBJECT_TYPE_IMAGE`	VkImage
`VK_OBJECT_TYPE_EVENT`	VkEvent
`VK_OBJECT_TYPE_QUERY_POOL`	VkQueryPool
`VK_OBJECT_TYPE_BUFFER_VIEW`	VkBufferView
`VK_OBJECT_TYPE_IMAGE_VIEW`	VkImageView
`VK_OBJECT_TYPE_SHADER_MODULE`	VkShaderModule
`VK_OBJECT_TYPE_PIPELINE_CACHE`	VkPipelineCache
`VK_OBJECT_TYPE_PIPELINE_LAYOUT`	VkPipelineLayout
`VK_OBJECT_TYPE_RENDER_PASS`	VkRenderPass
`VK_OBJECT_TYPE_PIPELINE`	VkPipeline
`VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT`	VkDescriptorSetLayout
`VK_OBJECT_TYPE_SAMPLER`	VkSampler
`VK_OBJECT_TYPE_DESCRIPTOR_POOL`	VkDescriptorPool
`VK_OBJECT_TYPE_DESCRIPTOR_SET`	VkDescriptorSet
`VK_OBJECT_TYPE_FRAMEBUFFER`	VkFramebuffer
`VK_OBJECT_TYPE_COMMAND_POOL`	VkCommandPool
`VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION`	VkSamplerYcbcrConversion
`VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE`	VkDescriptorUpdateTemplate
`VK_OBJECT_TYPE_SURFACE_KHR`	VkSurfaceKHR
`VK_OBJECT_TYPE_SWAPCHAIN_KHR`	VkSwapchainKHR
`VK_OBJECT_TYPE_DISPLAY_KHR`	VkDisplayKHR
`VK_OBJECT_TYPE_DISPLAY_MODE_KHR`	VkDisplayModeKHR
`VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT`	VkDebugReportCallbackEXT
`VK_OBJECT_TYPE_OBJECT_TABLE_NVX`	VkObjectTableNVX
`VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX`	VkIndirectCommandsLayoutNVX
`VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT`	VkDebugUtilsMessengerEXT
`VK_OBJECT_TYPE_VALIDATION_CACHE_EXT`	VkValidationCacheEXT
`VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV`	VkAccelerationStructureNV
`VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL`	VkPerformanceConfigurationINTEL

If this Specification was generated with any such extensions included, they will be described in the remainder of this chapter.

39.1. Debug Utilities

Vulkan provides flexible debugging utilities for debugging an application.

The Object Debug Annotation section describes how to associate either a name or binary data with a specific Vulkan object.

The Queue Labels section describes how to annotate and group the work submitted to a queue.

The Command Buffer Labels section describes how to associate logical elements of the scene with commands in a VkCommandBuffer.

The Debug Messengers section describes how to create debug messenger objects associated with an application supplied callback to capture debug messages from a variety of Vulkan components.

39.1.1. Object Debug Annotation

It can be useful for an application to provide its own content relative to a specific Vulkan object. The following commands allow application developers to associate user-defined information with Vulkan objects.

Object Naming

An object can be provided a user-defined name by calling vkSetDebugUtilsObjectNameEXT as defined below.

VkResult vkSetDebugUtilsObjectNameEXT(
    VkDevice                                    device,
    const VkDebugUtilsObjectNameInfoEXT*        pNameInfo);

device is the device that created the object.
pNameInfo is a pointer to a VkDebugUtilsObjectNameInfoEXT structure specifying parameters of the name to set on the object.

Valid Usage

VUID-vkSetDebugUtilsObjectNameEXT-pNameInfo-02587
pNameInfo->objectType must not be VK_OBJECT_TYPE_UNKNOWN
VUID-vkSetDebugUtilsObjectNameEXT-pNameInfo-02588
pNameInfo->objectHandle must not be VK_NULL_HANDLE

Valid Usage (Implicit)

VUID-vkSetDebugUtilsObjectNameEXT-device-parameter
device must be a valid VkDevice handle
VUID-vkSetDebugUtilsObjectNameEXT-pNameInfo-parameter
pNameInfo must be a valid pointer to a valid VkDebugUtilsObjectNameInfoEXT structure

Host Synchronization

Host access to pNameInfo.objectHandle must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkDebugUtilsObjectNameInfoEXT structure is defined as:

typedef struct VkDebugUtilsObjectNameInfoEXT {
    VkStructureType    sType;
    const void*        pNext;
    VkObjectType       objectType;
    uint64_t           objectHandle;
    const char*        pObjectName;
} VkDebugUtilsObjectNameInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
objectType is a VkObjectType specifying the type of the object to be named.
objectHandle is the object to be named.
pObjectName is a null-terminated UTF-8 string specifying the name to apply to objectHandle.

Applications may change the name associated with an object simply by calling vkSetDebugUtilsObjectNameEXT again with a new string. If pObjectName is an empty string, then any previously set name is removed.

Valid Usage

VUID-VkDebugUtilsObjectNameInfoEXT-objectType-02589
If objectType is VK_OBJECT_TYPE_UNKNOWN, objectHandle must not be VK_NULL_HANDLE
VUID-VkDebugUtilsObjectNameInfoEXT-objectType-02590
If objectType is not VK_OBJECT_TYPE_UNKNOWN, objectHandle must be VK_NULL_HANDLE or a valid Vulkan handle of the type associated with objectType as defined in the VkObjectType and Vulkan Handle Relationship table

Valid Usage (Implicit)

VUID-VkDebugUtilsObjectNameInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT
VUID-VkDebugUtilsObjectNameInfoEXT-pNext-pNext
pNext must be NULL
VUID-VkDebugUtilsObjectNameInfoEXT-objectType-parameter
objectType must be a valid VkObjectType value
VUID-VkDebugUtilsObjectNameInfoEXT-pObjectName-parameter
If pObjectName is not NULL, pObjectName must be a null-terminated UTF-8 string

Object Data Association

In addition to setting a name for an object, debugging and validation layers may have uses for additional binary data on a per-object basis that have no other place in the Vulkan API.

For example, a VkShaderModule could have additional debugging data attached to it to aid in offline shader tracing.

Additional data can be attached to an object by calling vkSetDebugUtilsObjectTagEXT as defined below.

VkResult vkSetDebugUtilsObjectTagEXT(
    VkDevice                                    device,
    const VkDebugUtilsObjectTagInfoEXT*         pTagInfo);

device is the device that created the object.
pTagInfo is a pointer to a VkDebugUtilsObjectTagInfoEXT structure specifying parameters of the tag to attach to the object.

Valid Usage (Implicit)

VUID-vkSetDebugUtilsObjectTagEXT-device-parameter
device must be a valid VkDevice handle
VUID-vkSetDebugUtilsObjectTagEXT-pTagInfo-parameter
pTagInfo must be a valid pointer to a valid VkDebugUtilsObjectTagInfoEXT structure

Host Synchronization

Host access to pTagInfo.objectHandle must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkDebugUtilsObjectTagInfoEXT structure is defined as:

typedef struct VkDebugUtilsObjectTagInfoEXT {
    VkStructureType    sType;
    const void*        pNext;
    VkObjectType       objectType;
    uint64_t           objectHandle;
    uint64_t           tagName;
    size_t             tagSize;
    const void*        pTag;
} VkDebugUtilsObjectTagInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
objectType is a VkObjectType specifying the type of the object to be named.
objectHandle is the object to be tagged.
tagName is a numerical identifier of the tag.
tagSize is the number of bytes of data to attach to the object.
pTag is a pointer to an array of tagSize bytes containing the data to be associated with the object.

The tagName parameter gives a name or identifier to the type of data being tagged. This can be used by debugging layers to easily filter for only data that can be used by that implementation.

Valid Usage

VUID-VkDebugUtilsObjectTagInfoEXT-objectType-01908
objectType must not be VK_OBJECT_TYPE_UNKNOWN
VUID-VkDebugUtilsObjectTagInfoEXT-objectHandle-01910
objectHandle must be a valid Vulkan handle of the type associated with objectType as defined in the VkObjectType and Vulkan Handle Relationship table

Valid Usage (Implicit)

VUID-VkDebugUtilsObjectTagInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT
VUID-VkDebugUtilsObjectTagInfoEXT-pNext-pNext
pNext must be NULL
VUID-VkDebugUtilsObjectTagInfoEXT-objectType-parameter
objectType must be a valid VkObjectType value
VUID-VkDebugUtilsObjectTagInfoEXT-pTag-parameter
pTag must be a valid pointer to an array of tagSize bytes
VUID-VkDebugUtilsObjectTagInfoEXT-tagSize-arraylength
tagSize must be greater than 0

39.1.2. Queue Labels

All Vulkan work must be submitted using queues. It is possible for an application to use multiple queues, each containing multiple command buffers, when performing work. It can be useful to identify which queue, or even where in a queue, something has occurred.

To begin identifying a region using a debug label inside a queue, you may use the vkQueueBeginDebugUtilsLabelEXT command.

Then, when the region of interest has passed, you may end the label region using vkQueueEndDebugUtilsLabelEXT.

Additionally, a single debug label may be inserted at any time using vkQueueInsertDebugUtilsLabelEXT.

A queue debug label region is opened by calling:

void vkQueueBeginDebugUtilsLabelEXT(
    VkQueue                                     queue,
    const VkDebugUtilsLabelEXT*                 pLabelInfo);

queue is the queue in which to start a debug label region.
pLabelInfo is a pointer to a VkDebugUtilsLabelEXT structure specifying parameters of the label region to open.

Valid Usage (Implicit)

VUID-vkQueueBeginDebugUtilsLabelEXT-queue-parameter
queue must be a valid VkQueue handle
VUID-vkQueueBeginDebugUtilsLabelEXT-pLabelInfo-parameter
pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure

Command Properties

Any

The VkDebugUtilsLabelEXT structure is defined as:

typedef struct VkDebugUtilsLabelEXT {
    VkStructureType    sType;
    const void*        pNext;
    const char*        pLabelName;
    float              color[4];
} VkDebugUtilsLabelEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
pLabelName is a pointer to a null-terminated UTF-8 string containing the name of the label.
color is an optional RGBA color value that can be associated with the label. A particular implementation may choose to ignore this color value. The values contain RGBA values in order, in the range 0.0 to 1.0. If all elements in color are set to 0.0 then it is ignored.

Valid Usage (Implicit)

VUID-VkDebugUtilsLabelEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT
VUID-VkDebugUtilsLabelEXT-pNext-pNext
pNext must be NULL
VUID-VkDebugUtilsLabelEXT-pLabelName-parameter
pLabelName must be a null-terminated UTF-8 string

A queue debug label region is closed by calling:

void vkQueueEndDebugUtilsLabelEXT(
    VkQueue                                     queue);

queue is the queue in which a debug label region should be closed.

The calls to vkQueueBeginDebugUtilsLabelEXT and vkQueueEndDebugUtilsLabelEXT must be matched and balanced.

Valid Usage

VUID-vkQueueEndDebugUtilsLabelEXT-None-01911
There must be an outstanding vkQueueBeginDebugUtilsLabelEXT command prior to the vkQueueEndDebugUtilsLabelEXT on the queue

Valid Usage (Implicit)

VUID-vkQueueEndDebugUtilsLabelEXT-queue-parameter
queue must be a valid VkQueue handle

Command Properties

Any

A single label can be inserted into a queue by calling:

void vkQueueInsertDebugUtilsLabelEXT(
    VkQueue                                     queue,
    const VkDebugUtilsLabelEXT*                 pLabelInfo);

queue is the queue into which a debug label will be inserted.
pLabelInfo is a pointer to a VkDebugUtilsLabelEXT structure specifying parameters of the label to insert.

Valid Usage (Implicit)

VUID-vkQueueInsertDebugUtilsLabelEXT-queue-parameter
queue must be a valid VkQueue handle
VUID-vkQueueInsertDebugUtilsLabelEXT-pLabelInfo-parameter
pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure

Command Properties

Any

39.1.3. Command Buffer Labels

Typical Vulkan applications will submit many command buffers in each frame, with each command buffer containing a large number of individual commands. Being able to logically annotate regions of command buffers that belong together as well as hierarchically subdivide the frame is important to a developer’s ability to navigate the commands viewed holistically.

To identify the beginning of a debug label region in a command buffer, vkCmdBeginDebugUtilsLabelEXT can be used as defined below.

To indicate the end of a debug label region in a command buffer, vkCmdEndDebugUtilsLabelEXT can be used.

To insert a single command buffer debug label inside of a command buffer, vkCmdInsertDebugUtilsLabelEXT can be used as defined below.

A command buffer debug label region can be opened by calling:

void vkCmdBeginDebugUtilsLabelEXT(
    VkCommandBuffer                             commandBuffer,
    const VkDebugUtilsLabelEXT*                 pLabelInfo);

commandBuffer is the command buffer into which the command is recorded.
pLabelInfo is a pointer to a VkDebugUtilsLabelEXT structure specifying parameters of the label region to open.

Valid Usage (Implicit)

VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdBeginDebugUtilsLabelEXT-pLabelInfo-parameter
pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure
VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations

Host Synchronization

Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

A command buffer label region can be closed by calling:

void vkCmdEndDebugUtilsLabelEXT(
    VkCommandBuffer                             commandBuffer);

commandBuffer is the command buffer into which the command is recorded.

An application may open a debug label region in one command buffer and close it in another, or otherwise split debug label regions across multiple command buffers or multiple queue submissions. When viewed from the linear series of submissions to a single queue, the calls to vkCmdBeginDebugUtilsLabelEXT and vkCmdEndDebugUtilsLabelEXT must be matched and balanced.

Valid Usage

VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01912
There must be an outstanding vkCmdBeginDebugUtilsLabelEXT command prior to the vkCmdEndDebugUtilsLabelEXT on the queue that commandBuffer is submitted to
VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01913
If commandBuffer is a secondary command buffer, there must be an outstanding vkCmdBeginDebugUtilsLabelEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdEndDebugUtilsLabelEXT.

Valid Usage (Implicit)

VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations

Host Synchronization

Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

A single debug label can be inserted into a command buffer by calling:

void vkCmdInsertDebugUtilsLabelEXT(
    VkCommandBuffer                             commandBuffer,
    const VkDebugUtilsLabelEXT*                 pLabelInfo);

commandBuffer is the command buffer into which the command is recorded.
pInfo is a pointer to a VkDebugUtilsLabelEXT structure specifying parameters of the label to insert.

Valid Usage (Implicit)

VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdInsertDebugUtilsLabelEXT-pLabelInfo-parameter
pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure
VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations

Host Synchronization

Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

39.1.4. Debug Messengers

Vulkan allows an application to register multiple callbacks with any Vulkan component wishing to report debug information. Some callbacks may log the information to a file, others may cause a debug break point or other application defined behavior. A primary producer of callback messages are the validation layers. An application can register callbacks even when no validation layers are enabled, but they will only be called for the Vulkan loader and, if implemented, other layer and driver events.

A VkDebugUtilsMessengerEXT is a messenger object which handles passing along debug messages to a provided debug callback.

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT)

The debug messenger will provide detailed feedback on the application’s use of Vulkan when events of interest occur. When an event of interest does occur, the debug messenger will submit a debug message to the debug callback that was provided during its creation. Additionally, the debug messenger is responsible with filtering out debug messages that the callback is not interested in and will only provide desired debug messages.

A debug messenger triggers a debug callback with a debug message when an event of interest occurs. To create a debug messenger which will trigger a debug callback, call:

VkResult vkCreateDebugUtilsMessengerEXT(
    VkInstance                                  instance,
    const VkDebugUtilsMessengerCreateInfoEXT*   pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkDebugUtilsMessengerEXT*                   pMessenger);

instance the instance the messenger will be used with.
pCreateInfo is a pointer to a VkDebugUtilsMessengerCreateInfoEXT structure containing the callback pointer, as well as defining conditions under which this messenger will trigger the callback.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pMessenger is a pointer to a VkDebugUtilsMessengerEXT handle in which the created object is returned.

Valid Usage (Implicit)

VUID-vkCreateDebugUtilsMessengerEXT-instance-parameter
instance must be a valid VkInstance handle
VUID-vkCreateDebugUtilsMessengerEXT-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkDebugUtilsMessengerCreateInfoEXT structure
VUID-vkCreateDebugUtilsMessengerEXT-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateDebugUtilsMessengerEXT-pMessenger-parameter
pMessenger must be a valid pointer to a VkDebugUtilsMessengerEXT handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY

The application must ensure that vkCreateDebugUtilsMessengerEXT is not executed in parallel with any Vulkan command that is also called with instance or child of instance as the dispatchable argument.

The definition of VkDebugUtilsMessengerCreateInfoEXT is:

typedef struct VkDebugUtilsMessengerCreateInfoEXT {
    VkStructureType                         sType;
    const void*                             pNext;
    VkDebugUtilsMessengerCreateFlagsEXT     flags;
    VkDebugUtilsMessageSeverityFlagsEXT     messageSeverity;
    VkDebugUtilsMessageTypeFlagsEXT         messageType;
    PFN_vkDebugUtilsMessengerCallbackEXT    pfnUserCallback;
    void*                                   pUserData;
} VkDebugUtilsMessengerCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is 0 and reserved for future use.
messageSeverity is a bitmask of VkDebugUtilsMessageSeverityFlagBitsEXT specifying which severity of event(s) will cause this callback to be called.
messageType is a bitmask of VkDebugUtilsMessageTypeFlagBitsEXT specifying which type of event(s) will cause this callback to be called.
pfnUserCallback is the application callback function to call.
pUserData is user data to be passed to the callback.

For each VkDebugUtilsMessengerEXT that is created the VkDebugUtilsMessengerCreateInfoEXT::messageSeverity and VkDebugUtilsMessengerCreateInfoEXT::messageType determine when that VkDebugUtilsMessengerCreateInfoEXT::pfnUserCallback is called. The process to determine if the user’s pfnUserCallback is triggered when an event occurs is as follows:

The implementation will perform a bitwise AND of the event’s VkDebugUtilsMessageSeverityFlagBitsEXT with the messageSeverity provided during creation of the VkDebugUtilsMessengerEXT object.
1. If the value is 0, the message is skipped.
The implementation will perform bitwise AND of the event’s VkDebugUtilsMessageTypeFlagBitsEXT with the messageType provided during the creation of the VkDebugUtilsMessengerEXT object.
1. If the value is 0, the message is skipped.
The callback will trigger a debug message for the current event

The callback will come directly from the component that detected the event, unless some other layer intercepts the calls for its own purposes (filter them in a different way, log to a system error log, etc.).

An application can receive multiple callbacks if multiple VkDebugUtilsMessengerEXT objects are created. A callback will always be executed in the same thread as the originating Vulkan call.

A callback can be called from multiple threads simultaneously (if the application is making Vulkan calls from multiple threads).

Valid Usage

VUID-VkDebugUtilsMessengerCreateInfoEXT-pfnUserCallback-01914
pfnUserCallback must be a valid PFN_vkDebugUtilsMessengerCallbackEXT

Valid Usage (Implicit)

VUID-VkDebugUtilsMessengerCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT
VUID-VkDebugUtilsMessengerCreateInfoEXT-flags-zerobitmask
flags must be 0
VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-parameter
messageSeverity must be a valid combination of VkDebugUtilsMessageSeverityFlagBitsEXT values
VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-requiredbitmask
messageSeverity must not be 0
VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-parameter
messageType must be a valid combination of VkDebugUtilsMessageTypeFlagBitsEXT values
VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-requiredbitmask
messageType must not be 0
VUID-VkDebugUtilsMessengerCreateInfoEXT-pfnUserCallback-parameter
pfnUserCallback must be a valid PFN_vkDebugUtilsMessengerCallbackEXT value

Bits which can be set in VkDebugUtilsMessengerCreateInfoEXT::messageSeverity, specifying event severities which cause a debug messenger to call the callback, are:

typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT {
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001,
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010,
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100,
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000,
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
} VkDebugUtilsMessageSeverityFlagBitsEXT;

VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT specifies the most verbose output indicating all diagnostic messages from the Vulkan loader, layers, and drivers should be captured.
VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT specifies an informational message such as resource details that may be handy when debugging an application.
VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT specifies use of Vulkan that may expose an app bug. Such cases may not be immediately harmful, such as a fragment shader outputting to a location with no attachment. Other cases may point to behavior that is almost certainly bad when unintended such as using an image whose memory has not been filled. In general if you see a warning but you know that the behavior is intended/desired, then simply ignore the warning.
VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT specifies that the application has violated a valid usage condition of the specification.

Note

The values of VkDebugUtilsMessageSeverityFlagBitsEXT are sorted based on severity. The higher the flag value, the more severe the message. This allows for simple boolean operation comparisons when looking at VkDebugUtilsMessageSeverityFlagBitsEXT values.

For example:

    if (messageSeverity >= VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
        // Do something for warnings and errors
    }

In addition, space has been left between the enums to allow for later addition of new severities in between the existing values.

typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT;

VkDebugUtilsMessageSeverityFlagsEXT is a bitmask type for setting a mask of zero or more VkDebugUtilsMessageSeverityFlagBitsEXT.

Bits which can be set in VkDebugUtilsMessengerCreateInfoEXT::messageType, specifying event types which cause a debug messenger to call the callback, are:

typedef enum VkDebugUtilsMessageTypeFlagBitsEXT {
    VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001,
    VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002,
    VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004,
    VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
} VkDebugUtilsMessageTypeFlagBitsEXT;

VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT specifies that some general event has occurred. This is typically a non-specification, non-performance event.
VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT specifies that something has occurred during validation against the Vulkan specification that may indicate invalid behavior.
VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT specifies a potentially non-optimal use of Vulkan, e.g. using vkCmdClearColorImage when setting VkAttachmentDescription::loadOp to VK_ATTACHMENT_LOAD_OP_CLEAR would have worked.

typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT;

VkDebugUtilsMessageTypeFlagsEXT is a bitmask type for setting a mask of zero or more VkDebugUtilsMessageTypeFlagBitsEXT.

The prototype for the VkDebugUtilsMessengerCreateInfoEXT::pfnUserCallback function implemented by the application is:

typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)(
    VkDebugUtilsMessageSeverityFlagBitsEXT           messageSeverity,
    VkDebugUtilsMessageTypeFlagsEXT                  messageTypes,
    const VkDebugUtilsMessengerCallbackDataEXT*      pCallbackData,
    void*                                            pUserData);

messageSeverity specifies the VkDebugUtilsMessageSeverityFlagBitsEXT that triggered this callback.
messageTypes is a bitmask of VkDebugUtilsMessageTypeFlagBitsEXT specifying which type of event(s) triggered this callback.
pCallbackData contains all the callback related data in the VkDebugUtilsMessengerCallbackDataEXT structure.
pUserData is the user data provided when the VkDebugUtilsMessengerEXT was created.

The callback must not call vkDestroyDebugUtilsMessengerEXT.

The callback returns a VkBool32, which is interpreted in a layer-specified manner. The application should always return VK_FALSE. The VK_TRUE value is reserved for use in layer development.

The definition of VkDebugUtilsMessengerCallbackDataEXT is:

typedef struct VkDebugUtilsMessengerCallbackDataEXT {
    VkStructureType                              sType;
    const void*                                  pNext;
    VkDebugUtilsMessengerCallbackDataFlagsEXT    flags;
    const char*                                  pMessageIdName;
    int32_t                                      messageIdNumber;
    const char*                                  pMessage;
    uint32_t                                     queueLabelCount;
    const VkDebugUtilsLabelEXT*                  pQueueLabels;
    uint32_t                                     cmdBufLabelCount;
    const VkDebugUtilsLabelEXT*                  pCmdBufLabels;
    uint32_t                                     objectCount;
    const VkDebugUtilsObjectNameInfoEXT*         pObjects;
} VkDebugUtilsMessengerCallbackDataEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is 0 and reserved for future use.
pMessageIdName is a null-terminated string that identifies the particular message ID that is associated with the provided message. If the message corresponds to a validation layer message, then this string may contain the portion of the Vulkan specification that is believed to have been violated.
messageIdNumber is the ID number of the triggering message. If the message corresponds to a validation layer message, then this number is related to the internal number associated with the message being triggered.
pMessage is a null-terminated string detailing the trigger conditions.
queueLabelCount is a count of items contained in the pQueueLabels array.
pQueueLabels is NULL or a pointer to an array of VkDebugUtilsLabelEXT active in the current VkQueue at the time the callback was triggered. Refer to Queue Labels for more information.
cmdBufLabelCount is a count of items contained in the pCmdBufLabels array.
pCmdBufLabels is NULL or a pointer to an array of VkDebugUtilsLabelEXT active in the current VkCommandBuffer at the time the callback was triggered. Refer to Command Buffer Labels for more information.
objectCount is a count of items contained in the pObjects array.
pObjects is a pointer to an array of VkDebugUtilsObjectNameInfoEXT objects related to the detected issue. The array is roughly in order or importance, but the 0th element is always guaranteed to be the most important object for this message.

Note

This structure should only be considered valid during the lifetime of the triggered callback.

Since adding queue and command buffer labels behaves like pushing and popping onto a stack, the order of both pQueueLabels and pCmdBufLabels is based on the order the labels were defined. The result is that the first label in either pQueueLabels or pCmdBufLabels will be the first defined (and therefore the oldest) while the last label in each list will be the most recent.

Note

pQueueLabels will only be non-NULL if one of the objects in pObjects can be related directly to a defined VkQueue which has had one or more labels associated with it.

Likewise, pCmdBufLabels will only be non-NULL if one of the objects in pObjects can be related directly to a defined VkCommandBuffer which has had one or more labels associated with it. Additionally, while command buffer labels allow for beginning and ending across different command buffers, the debug messaging framework cannot guarantee that labels in pCmdBufLables will contain those defined outside of the associated command buffer. This is partially due to the fact that the association of one command buffer with another may not have been defined at the time the debug message is triggered.

Valid Usage (Implicit)

VUID-VkDebugUtilsMessengerCallbackDataEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT
VUID-VkDebugUtilsMessengerCallbackDataEXT-pNext-pNext
pNext must be NULL
VUID-VkDebugUtilsMessengerCallbackDataEXT-flags-zerobitmask
flags must be 0
VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessageIdName-parameter
If pMessageIdName is not NULL, pMessageIdName must be a null-terminated UTF-8 string
VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessage-parameter
pMessage must be a null-terminated UTF-8 string
VUID-VkDebugUtilsMessengerCallbackDataEXT-pQueueLabels-parameter
If queueLabelCount is not 0, pQueueLabels must be a valid pointer to an array of queueLabelCount valid VkDebugUtilsLabelEXT structures
VUID-VkDebugUtilsMessengerCallbackDataEXT-pCmdBufLabels-parameter
If cmdBufLabelCount is not 0, pCmdBufLabels must be a valid pointer to an array of cmdBufLabelCount valid VkDebugUtilsLabelEXT structures
VUID-VkDebugUtilsMessengerCallbackDataEXT-pObjects-parameter
If objectCount is not 0, pObjects must be a valid pointer to an array of objectCount valid VkDebugUtilsObjectNameInfoEXT structures

There may be times that a user wishes to intentionally submit a debug message. To do this, call:

void vkSubmitDebugUtilsMessageEXT(
    VkInstance                                  instance,
    VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
    VkDebugUtilsMessageTypeFlagsEXT             messageTypes,
    const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);

instance is the debug stream’s VkInstance.
messageSeverity is the VkDebugUtilsMessageSeverityFlagBitsEXT severity of this event/message.
messageTypes is a bitmask of VkDebugUtilsMessageTypeFlagBitsEXT specifying which type of event(s) to identify with this message.
pCallbackData contains all the callback related data in the VkDebugUtilsMessengerCallbackDataEXT structure.

The call will propagate through the layers and generate callback(s) as indicated by the message’s flags. The parameters are passed on to the callback in addition to the pUserData value that was defined at the time the messenger was registered.

Valid Usage

VUID-vkSubmitDebugUtilsMessageEXT-objectType-02591
The objectType member of each element of pCallbackData->pObjects must not be VK_OBJECT_TYPE_UNKNOWN

Valid Usage (Implicit)

VUID-vkSubmitDebugUtilsMessageEXT-instance-parameter
instance must be a valid VkInstance handle
VUID-vkSubmitDebugUtilsMessageEXT-messageSeverity-parameter
messageSeverity must be a valid VkDebugUtilsMessageSeverityFlagBitsEXT value
VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-parameter
messageTypes must be a valid combination of VkDebugUtilsMessageTypeFlagBitsEXT values
VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-requiredbitmask
messageTypes must not be 0
VUID-vkSubmitDebugUtilsMessageEXT-pCallbackData-parameter
pCallbackData must be a valid pointer to a valid VkDebugUtilsMessengerCallbackDataEXT structure

To destroy a VkDebugUtilsMessengerEXT object, call:

void vkDestroyDebugUtilsMessengerEXT(
    VkInstance                                  instance,
    VkDebugUtilsMessengerEXT                    messenger,
    const VkAllocationCallbacks*                pAllocator);

instance the instance where the callback was created.
messenger the VkDebugUtilsMessengerEXT object to destroy. messenger is an externally synchronized object and must not be used on more than one thread at a time. This means that vkDestroyDebugUtilsMessengerEXT must not be called when a callback is active.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01915
If VkAllocationCallbacks were provided when messenger was created, a compatible set of callbacks must be provided here
VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01916
If no VkAllocationCallbacks were provided when messenger was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyDebugUtilsMessengerEXT-instance-parameter
instance must be a valid VkInstance handle
VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parameter
messenger must be a valid VkDebugUtilsMessengerEXT handle
VUID-vkDestroyDebugUtilsMessengerEXT-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parent
messenger must have been created, allocated, or retrieved from instance

Host Synchronization

Host access to messenger must be externally synchronized

The application must ensure that vkDestroyDebugUtilsMessengerEXT is not executed in parallel with any Vulkan command that is also called with instance or child of instance as the dispatchable argument.

39.2. Debug Markers

Debug markers provide a flexible way for debugging and validation layers to receive annotation and debug information.

The Object Annotation section describes how to associate a name or binary data with a Vulkan object.

The Command Buffer Markers section describes how to associate logical elements of the scene with commands in the command buffer.

39.2.1. Object Annotation

The commands in this section allow application developers to associate user-defined information with Vulkan objects at will.

An object can be given a user-friendly name by calling:

VkResult vkDebugMarkerSetObjectNameEXT(
    VkDevice                                    device,
    const VkDebugMarkerObjectNameInfoEXT*       pNameInfo);

device is the device that created the object.
pNameInfo is a pointer to a VkDebugMarkerObjectNameInfoEXT structure specifying the parameters of the name to set on the object.

Valid Usage (Implicit)

VUID-vkDebugMarkerSetObjectNameEXT-device-parameter
device must be a valid VkDevice handle
VUID-vkDebugMarkerSetObjectNameEXT-pNameInfo-parameter
pNameInfo must be a valid pointer to a valid VkDebugMarkerObjectNameInfoEXT structure

Host Synchronization

Host access to pNameInfo.object must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkDebugMarkerObjectNameInfoEXT structure is defined as:

typedef struct VkDebugMarkerObjectNameInfoEXT {
    VkStructureType               sType;
    const void*                   pNext;
    VkDebugReportObjectTypeEXT    objectType;
    uint64_t                      object;
    const char*                   pObjectName;
} VkDebugMarkerObjectNameInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
objectType is a VkDebugReportObjectTypeEXT specifying the type of the object to be named.
object is the object to be named.
pObjectName is a null-terminated UTF-8 string specifying the name to apply to object.

Applications may change the name associated with an object simply by calling vkDebugMarkerSetObjectNameEXT again with a new string. To remove a previously set name, pObjectName should be set to an empty string.

Valid Usage

VUID-VkDebugMarkerObjectNameInfoEXT-objectType-01490
objectType must not be VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT
VUID-VkDebugMarkerObjectNameInfoEXT-object-01491
object must not be VK_NULL_HANDLE
VUID-VkDebugMarkerObjectNameInfoEXT-object-01492
object must be a Vulkan object of the type associated with objectType as defined in VkDebugReportObjectTypeEXT and Vulkan Handle Relationship.

Valid Usage (Implicit)

VUID-VkDebugMarkerObjectNameInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT
VUID-VkDebugMarkerObjectNameInfoEXT-pNext-pNext
pNext must be NULL
VUID-VkDebugMarkerObjectNameInfoEXT-objectType-parameter
objectType must be a valid VkDebugReportObjectTypeEXT value
VUID-VkDebugMarkerObjectNameInfoEXT-pObjectName-parameter
pObjectName must be a null-terminated UTF-8 string

In addition to setting a name for an object, debugging and validation layers may have uses for additional binary data on a per-object basis that has no other place in the Vulkan API. For example, a VkShaderModule could have additional debugging data attached to it to aid in offline shader tracing. To attach data to an object, call:

VkResult vkDebugMarkerSetObjectTagEXT(
    VkDevice                                    device,
    const VkDebugMarkerObjectTagInfoEXT*        pTagInfo);

device is the device that created the object.
pTagInfo is a pointer to a VkDebugMarkerObjectTagInfoEXT structure specifying the parameters of the tag to attach to the object.

Valid Usage (Implicit)

VUID-vkDebugMarkerSetObjectTagEXT-device-parameter
device must be a valid VkDevice handle
VUID-vkDebugMarkerSetObjectTagEXT-pTagInfo-parameter
pTagInfo must be a valid pointer to a valid VkDebugMarkerObjectTagInfoEXT structure

Host Synchronization

Host access to pTagInfo.object must be externally synchronized

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkDebugMarkerObjectTagInfoEXT structure is defined as:

typedef struct VkDebugMarkerObjectTagInfoEXT {
    VkStructureType               sType;
    const void*                   pNext;
    VkDebugReportObjectTypeEXT    objectType;
    uint64_t                      object;
    uint64_t                      tagName;
    size_t                        tagSize;
    const void*                   pTag;
} VkDebugMarkerObjectTagInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
objectType is a VkDebugReportObjectTypeEXT specifying the type of the object to be named.
object is the object to be tagged.
tagName is a numerical identifier of the tag.
tagSize is the number of bytes of data to attach to the object.
pTag is a pointer to an array of tagSize bytes containing the data to be associated with the object.

The tagName parameter gives a name or identifier to the type of data being tagged. This can be used by debugging layers to easily filter for only data that can be used by that implementation.

Valid Usage

VUID-VkDebugMarkerObjectTagInfoEXT-objectType-01493
objectType must not be VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT
VUID-VkDebugMarkerObjectTagInfoEXT-object-01494
object must not be VK_NULL_HANDLE
VUID-VkDebugMarkerObjectTagInfoEXT-object-01495
object must be a Vulkan object of the type associated with objectType as defined in VkDebugReportObjectTypeEXT and Vulkan Handle Relationship.

Valid Usage (Implicit)

VUID-VkDebugMarkerObjectTagInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT
VUID-VkDebugMarkerObjectTagInfoEXT-pNext-pNext
pNext must be NULL
VUID-VkDebugMarkerObjectTagInfoEXT-objectType-parameter
objectType must be a valid VkDebugReportObjectTypeEXT value
VUID-VkDebugMarkerObjectTagInfoEXT-pTag-parameter
pTag must be a valid pointer to an array of tagSize bytes
VUID-VkDebugMarkerObjectTagInfoEXT-tagSize-arraylength
tagSize must be greater than 0

39.2.2. Command Buffer Markers

The marker commands vkCmdDebugMarkerBeginEXT and vkCmdDebugMarkerEndEXT define regions of a series of commands that are grouped together, and they can be nested to create a hierarchy. The vkCmdDebugMarkerInsertEXT command allows insertion of a single label within a command buffer.

A marker region can be opened by calling:

void vkCmdDebugMarkerBeginEXT(
    VkCommandBuffer                             commandBuffer,
    const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);

commandBuffer is the command buffer into which the command is recorded.
pMarkerInfo is a pointer to a VkDebugMarkerMarkerInfoEXT structure specifying the parameters of the marker region to open.

Valid Usage (Implicit)

VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdDebugMarkerBeginEXT-pMarkerInfo-parameter
pMarkerInfo must be a valid pointer to a valid VkDebugMarkerMarkerInfoEXT structure
VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations

Host Synchronization

Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

The VkDebugMarkerMarkerInfoEXT structure is defined as:

typedef struct VkDebugMarkerMarkerInfoEXT {
    VkStructureType    sType;
    const void*        pNext;
    const char*        pMarkerName;
    float              color[4];
} VkDebugMarkerMarkerInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
pMarkerName is a pointer to a null-terminated UTF-8 string containing the name of the marker.
color is an optional RGBA color value that can be associated with the marker. A particular implementation may choose to ignore this color value. The values contain RGBA values in order, in the range 0.0 to 1.0. If all elements in color are set to 0.0 then it is ignored.

Valid Usage (Implicit)

VUID-VkDebugMarkerMarkerInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT
VUID-VkDebugMarkerMarkerInfoEXT-pNext-pNext
pNext must be NULL
VUID-VkDebugMarkerMarkerInfoEXT-pMarkerName-parameter
pMarkerName must be a null-terminated UTF-8 string

A marker region can be closed by calling:

void vkCmdDebugMarkerEndEXT(
    VkCommandBuffer                             commandBuffer);

commandBuffer is the command buffer into which the command is recorded.

An application may open a marker region in one command buffer and close it in another, or otherwise split marker regions across multiple command buffers or multiple queue submissions. When viewed from the linear series of submissions to a single queue, the calls to vkCmdDebugMarkerBeginEXT and vkCmdDebugMarkerEndEXT must be matched and balanced.

Valid Usage

VUID-vkCmdDebugMarkerEndEXT-commandBuffer-01239
There must be an outstanding vkCmdDebugMarkerBeginEXT command prior to the vkCmdDebugMarkerEndEXT on the queue that commandBuffer is submitted to
VUID-vkCmdDebugMarkerEndEXT-commandBuffer-01240
If commandBuffer is a secondary command buffer, there must be an outstanding vkCmdDebugMarkerBeginEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdDebugMarkerEndEXT.

Valid Usage (Implicit)

VUID-vkCmdDebugMarkerEndEXT-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdDebugMarkerEndEXT-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdDebugMarkerEndEXT-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations

Host Synchronization

Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

A single marker label can be inserted into a command buffer by calling:

void vkCmdDebugMarkerInsertEXT(
    VkCommandBuffer                             commandBuffer,
    const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);

commandBuffer is the command buffer into which the command is recorded.
pMarkerInfo is a pointer to a VkDebugMarkerMarkerInfoEXT structure specifying the parameters of the marker to insert.

Valid Usage (Implicit)

VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdDebugMarkerInsertEXT-pMarkerInfo-parameter
pMarkerInfo must be a valid pointer to a valid VkDebugMarkerMarkerInfoEXT structure
VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations

Host Synchronization

Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute

39.3. Debug Report Callbacks

Debug report callbacks are represented by VkDebugReportCallbackEXT handles:

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)

Debug report callbacks give more detailed feedback on the application’s use of Vulkan when events of interest occur.

To register a debug report callback, an application uses vkCreateDebugReportCallbackEXT.

VkResult vkCreateDebugReportCallbackEXT(
    VkInstance                                  instance,
    const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkDebugReportCallbackEXT*                   pCallback);

instance the instance the callback will be logged on.
pCreateInfo is a pointer to a VkDebugReportCallbackCreateInfoEXT structure defining the conditions under which this callback will be called.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pCallback is a pointer to a VkDebugReportCallbackEXT handle in which the created object is returned.

Valid Usage (Implicit)

VUID-vkCreateDebugReportCallbackEXT-instance-parameter
instance must be a valid VkInstance handle
VUID-vkCreateDebugReportCallbackEXT-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkDebugReportCallbackCreateInfoEXT structure
VUID-vkCreateDebugReportCallbackEXT-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkCreateDebugReportCallbackEXT-pCallback-parameter
pCallback must be a valid pointer to a VkDebugReportCallbackEXT handle

Return Codes

VK_SUCCESS

VK_ERROR_OUT_OF_HOST_MEMORY

The definition of VkDebugReportCallbackCreateInfoEXT is:

typedef struct VkDebugReportCallbackCreateInfoEXT {
    VkStructureType                 sType;
    const void*                     pNext;
    VkDebugReportFlagsEXT           flags;
    PFN_vkDebugReportCallbackEXT    pfnCallback;
    void*                           pUserData;
} VkDebugReportCallbackCreateInfoEXT;

sType is the type of this structure.
pNext is NULL or a pointer to an extension-specific structure.
flags is a bitmask of VkDebugReportFlagBitsEXT specifying which event(s) will cause this callback to be called.
pfnCallback is the application callback function to call.
pUserData is user data to be passed to the callback.

For each VkDebugReportCallbackEXT that is created the VkDebugReportCallbackCreateInfoEXT::flags determine when that VkDebugReportCallbackCreateInfoEXT::pfnCallback is called. When an event happens, the implementation will do a bitwise AND of the event’s VkDebugReportFlagBitsEXT flags to each VkDebugReportCallbackEXT object’s flags. For each non-zero result the corresponding callback will be called. The callback will come directly from the component that detected the event, unless some other layer intercepts the calls for its own purposes (filter them in a different way, log to a system error log, etc.).

An application may receive multiple callbacks if multiple VkDebugReportCallbackEXT objects were created. A callback will always be executed in the same thread as the originating Vulkan call.

A callback may be called from multiple threads simultaneously (if the application is making Vulkan calls from multiple threads).

Valid Usage (Implicit)

VUID-VkDebugReportCallbackCreateInfoEXT-sType-sType
sType must be VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT
VUID-VkDebugReportCallbackCreateInfoEXT-flags-parameter
flags must be a valid combination of VkDebugReportFlagBitsEXT values
VUID-VkDebugReportCallbackCreateInfoEXT-pfnCallback-parameter
pfnCallback must be a valid PFN_vkDebugReportCallbackEXT value

Bits which can be set in VkDebugReportCallbackCreateInfoEXT::flags, specifying events which cause a debug report, are:

typedef enum VkDebugReportFlagBitsEXT {
    VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001,
    VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002,
    VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004,
    VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008,
    VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010,
    VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
} VkDebugReportFlagBitsEXT;

VK_DEBUG_REPORT_ERROR_BIT_EXT specifies that the application has violated a valid usage condition of the specification.
VK_DEBUG_REPORT_WARNING_BIT_EXT specifies use of Vulkan that may expose an app bug. Such cases may not be immediately harmful, such as a fragment shader outputting to a location with no attachment. Other cases may point to behavior that is almost certainly bad when unintended such as using an image whose memory has not been filled. In general if you see a warning but you know that the behavior is intended/desired, then simply ignore the warning.
VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT specifies a potentially non-optimal use of Vulkan, e.g. using vkCmdClearColorImage when setting VkAttachmentDescription::loadOp to VK_ATTACHMENT_LOAD_OP_CLEAR would have worked.
VK_DEBUG_REPORT_INFORMATION_BIT_EXT specifies an informational message such as resource details that may be handy when debugging an application.
VK_DEBUG_REPORT_DEBUG_BIT_EXT specifies diagnostic information from the implementation and layers.

typedef VkFlags VkDebugReportFlagsEXT;

VkDebugReportFlagsEXT is a bitmask type for setting a mask of zero or more VkDebugReportFlagBitsEXT.

The prototype for the VkDebugReportCallbackCreateInfoEXT::pfnCallback function implemented by the application is:

typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(
    VkDebugReportFlagsEXT                       flags,
    VkDebugReportObjectTypeEXT                  objectType,
    uint64_t                                    object,
    size_t                                      location,
    int32_t                                     messageCode,
    const char*                                 pLayerPrefix,
    const char*                                 pMessage,
    void*                                       pUserData);

flags specifies the VkDebugReportFlagBitsEXT that triggered this callback.
objectType is a VkDebugReportObjectTypeEXT value specifying the type of object being used or created at the time the event was triggered.
object is the object where the issue was detected. If objectType is VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, object is undefined.
location is a component (layer, driver, loader) defined value specifying the location of the trigger. This is an optional value.
messageCode is a layer-defined value indicating what test triggered this callback.
pLayerPrefix is a null-terminated string that is an abbreviation of the name of the component making the callback. pLayerPrefix is only valid for the duration of the callback.
pMessage is a null-terminated string detailing the trigger conditions. pMessage is only valid for the duration of the callback.
pUserData is the user data given when the VkDebugReportCallbackEXT was created.

The callback must not call vkDestroyDebugReportCallbackEXT.

The callback returns a VkBool32, which is interpreted in a layer-specified manner. The application should always return VK_FALSE. The VK_TRUE value is reserved for use in layer development.

object must be a Vulkan object or VK_NULL_HANDLE. If objectType is not VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT and object is not VK_NULL_HANDLE, object must be a Vulkan object of the corresponding type associated with objectType as defined in VkDebugReportObjectTypeEXT and Vulkan Handle Relationship.

Possible values passed to the objectType parameter of the callback function specified by VkDebugReportCallbackCreateInfoEXT::pfnCallback, specifying the type of object handle being reported, are:

typedef enum VkDebugReportObjectTypeEXT {
    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
    VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
    VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
    VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
    VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
    VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
    VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
    VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
    VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
    VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
    VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
    VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
    VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
    VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
    VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28,
    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29,
    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30,
    VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31,
    VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32,
    VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33,
    VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000,
    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000,
    VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000,
    VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
    VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
    VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
    VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
} VkDebugReportObjectTypeEXT;

Table 74. VkDebugReportObjectTypeEXT and Vulkan Handle Relationship
VkDebugReportObjectTypeEXT	Vulkan Handle Type
`VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT`	Unknown/Undefined Handle
`VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT`	VkInstance
`VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT`	VkPhysicalDevice
`VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT`	VkDevice
`VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT`	VkQueue
`VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT`	VkSemaphore
`VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT`	VkCommandBuffer
`VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT`	VkFence
`VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT`	VkDeviceMemory
`VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT`	VkBuffer
`VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT`	VkImage
`VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT`	VkEvent
`VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT`	VkQueryPool
`VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT`	VkBufferView
`VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT`	VkImageView
`VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT`	VkShaderModule
`VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT`	VkPipelineCache
`VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT`	VkPipelineLayout
`VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT`	VkRenderPass
`VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT`	VkPipeline
`VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT`	VkDescriptorSetLayout
`VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT`	VkSampler
`VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT`	VkDescriptorPool
`VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT`	VkDescriptorSet
`VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT`	VkFramebuffer
`VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT`	VkCommandPool
`VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT`	VkSurfaceKHR
`VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT`	VkSwapchainKHR
`VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT`	VkDebugReportCallbackEXT
`VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT`	VkDisplayKHR
`VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT`	VkDisplayModeKHR
`VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT`	VkObjectTableNVX
`VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT`	VkIndirectCommandsLayoutNVX
`VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT`	VkDescriptorUpdateTemplate

Note

The primary expected use of VK_ERROR_VALIDATION_FAILED_EXT is for validation layer testing. It is not expected that an application would see this error code during normal use of the validation layers.

To inject its own messages into the debug stream, call:

void vkDebugReportMessageEXT(
    VkInstance                                  instance,
    VkDebugReportFlagsEXT                       flags,
    VkDebugReportObjectTypeEXT                  objectType,
    uint64_t                                    object,
    size_t                                      location,
    int32_t                                     messageCode,
    const char*                                 pLayerPrefix,
    const char*                                 pMessage);

instance is the debug stream’s VkInstance.
flags specifies the VkDebugReportFlagBitsEXT classification of this event/message.
objectType is a VkDebugReportObjectTypeEXT specifying the type of object being used or created at the time the event was triggered.
object this is the object where the issue was detected. object can be VK_NULL_HANDLE if there is no object associated with the event.
location is an application defined value.
messageCode is an application defined value.
pLayerPrefix is the abbreviation of the component making this event/message.
pMessage is a null-terminated string detailing the trigger conditions.

Valid Usage

VUID-vkDebugReportMessageEXT-object-01241
object must be a Vulkan object or VK_NULL_HANDLE
VUID-vkDebugReportMessageEXT-objectType-01498
If objectType is not VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT and object is not VK_NULL_HANDLE, object must be a Vulkan object of the corresponding type associated with objectType as defined in VkDebugReportObjectTypeEXT and Vulkan Handle Relationship.

Valid Usage (Implicit)

VUID-vkDebugReportMessageEXT-instance-parameter
instance must be a valid VkInstance handle
VUID-vkDebugReportMessageEXT-flags-parameter
flags must be a valid combination of VkDebugReportFlagBitsEXT values
VUID-vkDebugReportMessageEXT-flags-requiredbitmask
flags must not be 0
VUID-vkDebugReportMessageEXT-objectType-parameter
objectType must be a valid VkDebugReportObjectTypeEXT value
VUID-vkDebugReportMessageEXT-pLayerPrefix-parameter
pLayerPrefix must be a null-terminated UTF-8 string
VUID-vkDebugReportMessageEXT-pMessage-parameter
pMessage must be a null-terminated UTF-8 string

To destroy a VkDebugReportCallbackEXT object, call:

void vkDestroyDebugReportCallbackEXT(
    VkInstance                                  instance,
    VkDebugReportCallbackEXT                    callback,
    const VkAllocationCallbacks*                pAllocator);

instance the instance where the callback was created.
callback the VkDebugReportCallbackEXT object to destroy. callback is an externally synchronized object and must not be used on more than one thread at a time. This means that vkDestroyDebugReportCallbackEXT must not be called when a callback is active.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

VUID-vkDestroyDebugReportCallbackEXT-instance-01242
If VkAllocationCallbacks were provided when callback was created, a compatible set of callbacks must be provided here
VUID-vkDestroyDebugReportCallbackEXT-instance-01243
If no VkAllocationCallbacks were provided when callback was created, pAllocator must be NULL

Valid Usage (Implicit)

VUID-vkDestroyDebugReportCallbackEXT-instance-parameter
instance must be a valid VkInstance handle
VUID-vkDestroyDebugReportCallbackEXT-callback-parameter
callback must be a valid VkDebugReportCallbackEXT handle
VUID-vkDestroyDebugReportCallbackEXT-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
VUID-vkDestroyDebugReportCallbackEXT-callback-parent
callback must have been created, allocated, or retrieved from instance

Host Synchronization

Host access to callback must be externally synchronized

39.4. Device Loss Debugging

39.4.1. Device Diagnostic Checkpoints

Device execution progress can be tracked for the purposes of debugging a device loss by annotating the command stream with application-defined diagnostic checkpoints.

Each diagnostic checkpoint command is executed at two pipeline stages: VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, and VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT. If the device is lost, the application can call vkGetQueueCheckpointDataNV to retrieve checkpoint data associated with both pipeline stages, indicating the range of diagnostic checkpoints that are currently in the execution pipeline on the device.

Device diagnostic checkpoints are inserted into the command stream by calling vkCmdSetCheckpointNV.

void vkCmdSetCheckpointNV(
    VkCommandBuffer                             commandBuffer,
    const void*                                 pCheckpointMarker);

commandBuffer is the command buffer that will receive the marker
pCheckpointMarker is an opaque application-provided value that will be associated with the checkpoint.

Valid Usage (Implicit)

VUID-vkCmdSetCheckpointNV-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle
VUID-vkCmdSetCheckpointNV-commandBuffer-recording
commandBuffer must be in the recording state
VUID-vkCmdSetCheckpointNV-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics, compute, or transfer operations

Host Synchronization

Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

Primary
Secondary

Both

Graphics
Compute
Transfer

Note that pCheckpointMarker is treated as an opaque value. It does not need to be a valid pointer and will not be dereferenced by the implementation.

If the device encounters an error during execution, the implementation will return a VK_ERROR_DEVICE_LOST error to the application at a certain point during host execution. When this happens, the application can call vkGetQueueCheckpointDataNV to retrieve information on the most recent diagnostic checkpoints that were executed by the device.

void vkGetQueueCheckpointDataNV(
    VkQueue                                     queue,
    uint32_t*                                   pCheckpointDataCount,
    VkCheckpointDataNV*                         pCheckpointData);

queue is the VkQueue object the caller would like to retrieve checkpoint data for
pCheckpointDataCount is a pointer to an integer related to the number of checkpoint markers available or queried, as described below.
pCheckpointData is either NULL or a pointer to an array of VkCheckpointDataNV structures.

If pCheckpointData is NULL, then the number of checkpoint markers available is returned in pCheckpointDataCount.

Otherwise, pCheckpointDataCount must point to a variable set by the user to the number of elements in the pCheckpointData array, and on return the variable is overwritten with the number of structures actually written to pCheckpointData.

If pCheckpointDataCount is less than the number of checkpoint markers available, at most pCheckpointDataCount structures will be written.

Valid Usage

VUID-vkGetQueueCheckpointDataNV-queue-02025
The device that queue belongs to must be in the lost state

Valid Usage (Implicit)

VUID-vkGetQueueCheckpointDataNV-queue-parameter
queue must be a valid VkQueue handle
VUID-vkGetQueueCheckpointDataNV-pCheckpointDataCount-parameter
pCheckpointDataCount must be a valid pointer to a uint32_t value
VUID-vkGetQueueCheckpointDataNV-pCheckpointData-parameter
If the value referenced by pCheckpointDataCount is not 0, and pCheckpointData is not NULL, pCheckpointData must be a valid pointer to an array of pCheckpointDataCount VkCheckpointDataNV structures

The VkCheckpointDataNV structure is defined as:

typedef struct VkCheckpointDataNV {
    VkStructureType            sType;
    void*                      pNext;
    VkPipelineStageFlagBits    stage;
    void*                      pCheckpointMarker;
} VkCheckpointDataNV;

sType is the type of this structure
pNext is NULL or a pointer to an extension-specific structure.
stage indicates which pipeline stage the checkpoint marker data refers to.
pCheckpointMarker contains the value of the last checkpoint marker executed in the stage that stage refers to.

Valid Usage (Implicit)

VUID-VkCheckpointDataNV-sType-sType
sType must be VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV
VUID-VkCheckpointDataNV-pNext-pNext
pNext must be NULL

Note that the stages at which a checkpoint marker can be executed are implementation-defined and can be queried by calling vkGetPhysicalDeviceQueueFamilyProperties2.

39.5. Active Tooling Information

Information about tools providing debugging, profiling, or similar services, active for a given physical device, can be obtained by calling:

VkResult vkGetPhysicalDeviceToolPropertiesEXT(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pToolCount,
    VkPhysicalDeviceToolPropertiesEXT*          pToolProperties);

physicalDevice is the handle to the physical device to query for active tools.
pToolCount is a pointer to an integer describing the number of tools active on physicalDevice.
pToolProperties is either NULL or a pointer to an array of VkPhysicalDeviceToolPropertiesEXT instances.

If pToolProperties is NULL, the implementation will return the number of tools currently active on physicalDevice in pToolCount.

If pToolProperties is not NULL, its elements are populate with information about active tools, up to the number stored in pToolCount; the number of elements actually returned is returned in pToolCount.

Valid Usage (Implicit)

VUID-vkGetPhysicalDeviceToolPropertiesEXT-physicalDevice-parameter
physicalDevice must be a valid VkPhysicalDevice handle
VUID-vkGetPhysicalDeviceToolPropertiesEXT-pToolCount-parameter
pToolCount must be a valid pointer to a uint32_t value
VUID-vkGetPhysicalDeviceToolPropertiesEXT-pToolProperties-parameter
If pToolProperties is not NULL, pToolProperties must be a valid pointer to an array of pToolCount VkPhysicalDeviceToolPropertiesEXT structures
VUID-vkGetPhysicalDeviceToolPropertiesEXT-pToolCount-arraylength
If pToolProperties is not NULL, the value referenced by pToolCount must be greater than 0

Return Codes