Vulkan^® 1.2.145 - A Specification (with all registered Vulkan extensions)

A descriptor binding is accessible to a shader stage if that stage is included in the stageFlags of the descriptor binding. Descriptors using that binding can only be used by stages in which they are accessible.

An operation that acquires ownership of an image subresource or buffer range.

Transform feedback is made active after vkCmdBeginTransformFeedbackEXT executes and remains active until vkCmdEndTransformFeedbackEXT executes. While transform feedback is active, data written to variables in the output interface of the last vertex processing stage of the graphics pipeline are captured to the bound transform feedback buffers if those variables are decorated for transform feedback.

A vertex in an adjacency primitive topology that is not part of a given primitive, but is accessible in geometry shaders.

A primitive or instance in a ray tracing acceleration structure which has a corresponding ID, and is not inactive (meaning that it is visible to rays).

Blending performed using one of the blend operation enums introduced by the VK_EXT_blend_operation_advanced extension. See Advanced Blending Operations.

An identical definition of another API type/command with the same behavior but a different name.

A range of a device memory allocation that is bound to multiple resources simultaneously.

An association of a host memory allocation to a parent object or command, where the allocation’s lifetime ends before or at the same time as the parent object is freed or destroyed, or during the parent command.

An image may contain multiple kinds, or aspects, of data for each pixel, where each aspect is used in a particular way by the pipeline and may be stored differently or separately from other aspects. For example, the color components of an image format make up the color aspect of the image, and may be used as a framebuffer color attachment. Some operations, like depth testing, operate only on specific aspects of an image. Others operations, like image/buffer copies, only operate on one aspect at a time.

A zero-based integer index name used in render pass creation to refer to a framebuffer attachment that is accessed by one or more subpasses. The index also refers to an attachment description which includes information about the properties of the image view that will later be attached.

An operation that causes the values generated by specified memory write accesses to become available for future access.

A state of values written to memory that allows them to be made visible.

A box bounding a region in space defined by extents along each axis and thus representing a box where each edge is aligned to one of the major axes.

See Facingness.

A single structure submitted to a queue as part of a queue submission command, describing a set of queue operations to execute.

A given version of the API is backwards compatible with an earlier version if an application, relying only on valid behavior and functionality defined by the earlier specification, is able to correctly run against each version without any modification. This assumes no active attempt by that application to not run when it detects a different version.

A semaphore with a boolean payload indicating whether the semaphore is signaled or unsignaled. Represented by a VkSemaphore object created with a semaphore type of VK_SEMAPHORE_TYPE_BINARY .

A given version of the API is fully compatible with another version if an application, relying only on valid behavior and functionality defined by either of those specifications, is able to correctly run against each version without any modification. This assumes no active attempt by that application to not run when it detects a different version.

An association established between a range of a resource object and a range of a memory object. These associations determine the memory locations affected by operations performed on elements of a resource object. Memory bindings are established using the vkBindBufferMemory command for non-sparse buffer objects, using the vkBindImageMemory command for non-sparse image objects, and using the vkQueueBindSparse command for sparse resources.

Four floating point (RGBA) values used as an input to blending.

Arithmetic operations between a fragment color value and a value in a color attachment that produce a final color value to be written to the attachment.

A resource that represents a linear array of data in device memory. Represented by a VkBuffer object.

A 64-bit value used in a shader to access buffer memory through the PhysicalStorageBuffer storage class.

An object that represents a range of a specific buffer, and state that controls how the contents are interpreted. Represented by a VkBufferView object.

A variable decorated in a shader, where the decoration makes the variable take values provided by the execution environment or values that are generated by fixed-function pipeline stages.

A block defined in a shader that contains only variables decorated with built-in decorations, and is used to match against other shader stages.

The homogeneous coordinate space that vertex positions (Position decoration) are written in by vertex processing stages.

A built-in output from vertex processing stages that defines a clip half-space against which the primitive is clipped.

The intersection of the view volume with all clip half-spaces.

A subpass attachment point, or image view, that is the target of fragment color outputs and blending.

A unique color value within a pixel of a multisampled color image. The fragment mask will contain indices to the color fragment.

A VkFormat where VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT is set in one of the following, depending on the image’s tiling:

A bitfield associated with a fragment, with one bit for each sample in the color attachment(s). Samples are considered to be covered based on the result of the Coverage Reduction stage. Uncovered samples do not write to color attachments.

A descriptor type that includes both a sampled image and a sampler.

An object that records commands to be submitted to a queue. Represented by a VkCommandBuffer object.

An object that command buffer memory is allocated from, and that owns that memory. Command pools aid multithreaded performance by enabling different threads to use different allocators, without internal synchronization on each use. Represented by a VkCommandPool object.

When allocators are compatible, allocations from each allocator can be freed by the other allocator.

When formats are compatible, images created with one of the formats can have image views created from it using any of the compatible formats. Also see Size-Compatible Image Formats.

Queues within a queue family. Compatible queues have identical properties.

The entire set of miplevels that can be provided for an image, from the largest application specified miplevel size down to the minimum miplevel size. See Image Miplevel Sizing.

A deferred operation whose corresponding command has been executed to completion. See Deferred Host Operations

A distinct part of a format. Depth, stencil, and color channels (e.g. R, G, B, A), are all separate components.

An element of an image having a block-compressed format, comprising a rectangular block of texel values that are encoded as a single value in memory. Compressed texel blocks of a particular block-compressed format have a corresponding width, height, and depth that define the dimensions of these elements in units of texels, and a size in bytes of the encoding in memory.

A SPIR-V constant instruction whose type is OpTypeInt. See Constant Instruction in section 2.2.1 “Instructions” of the Khronos SPIR-V Specification.

A SPIR-V type where the storage for and computations performed on the matrix are spread across a set of invocations such as a subgroup.

A VkImage where unnormalized texel coordinates are centered on integer values instead of half-integer values. Specified by setting the VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV bit on VkImageCreateInfo::flags at image creation.

The index of a sample in the coverage mask.

A bitfield associated with a fragment representing the samples that were determined to be covered based on the result of rasterization, and then subsequently modified by fragment operations or the fragment shader.

A built-in output from vertex processing stages that defines a cull half-space where the primitive is rejected if all vertices have a negative value for the same cull distance.

The intersection of the view volume with all cull half-spaces.

Auxiliary information such as built-in variables, stream numbers, invariance, interpolation type, relaxed precision, etc., added to variables or structure-type members through decorations.

A command which allows deferred execution of host-side work. See Deferred Host Operations.

A single logical item of host-side work which can be deferred. Represented by the VkDeferredOperationKHR object. See Deferred Host Operations.

A feature is deprecated if it is no longer recommended as the correct or best way to achieve its intended purpose.

A subpass attachment point, or image view, that is the target of depth and/or stencil test operations and writes.

A VkFormat that includes depth and/or stencil components.

A VkImage (or VkImageView) with a depth/stencil format.

A subpass attachment point, or image view, that is the target of a multisample resolve operation from the corresponding depth/stencil attachment at the end of the subpass.

A set of fragment or compute shader invocations that cooperate to compute derivatives, including implicit derivatives for sampled image operations.

Information about a resource or resource view written into a descriptor set that is used to access the resource or view from a shader.

An entry in a descriptor set layout corresponding to zero or more descriptors of a single descriptor type in a set. Defined by a VkDescriptorSetLayoutBinding structure.

An object that descriptor sets are allocated from, and that owns the storage of those descriptor sets. Descriptor pools aid multithreaded performance by enabling different threads to use different allocators, without internal synchronization on each use. Represented by a VkDescriptorPool object.

An object that resource descriptors are written into via the API, and that can be bound to a command buffer such that the descriptors contained within it can be accessed from shaders. Represented by a VkDescriptorSet object.

An object that defines the set of resources (types and counts) and their relative arrangement (in the binding namespace) within a descriptor set. Used when allocating descriptor sets and when creating pipeline layouts. Represented by a VkDescriptorSetLayout object.

The processor(s) and execution environment that perform tasks requested by the application via the Vulkan API.

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.

A zero-based integer that identifies one physical device from a logical device. A device index is valid if it is less than the number of physical devices in the logical device.

A bitmask where each bit represents one device index. A device mask value is valid if every bit that is set in the mask is at a bit position that is less than the number of physical devices in the logical device.

Memory accessible to the device. Represented by a VkDeviceMemory object.

Any command that is dispatched from a logical device, or from a child object of a logical device.

All device-level commands and objects, and their structures, enumerated types, and enumerants.

Logical device objects and their child objects. For example, VkDevice, VkQueue, and VkCommandBuffer objects are device-level objects.

Memory that is connected to the device, and may be more performant for device access than host-local memory.

Drawing commands that take all their parameters as direct arguments to the command (and not sourced via structures in buffer memory as the indirect drawing commands). Includes vkCmdDrawMeshTasksNV, vkCmdDraw, and vkCmdDrawIndexed.

Disjoint planes are image planes to which memory is bound independently.
A disjoint image consists of multiple disjoint planes, and is created with the VK_IMAGE_CREATE_DISJOINT_BIT bit set.

A handle of a pointer handle type which may be used by layers as part of intercepting API commands. The first argument to each Vulkan command is a dispatchable handle type.

Commands that provoke work using a compute pipeline. Includes vkCmdDispatch and vkCmdDispatchIndirect.

Commands that provoke work using a graphics pipeline. Includes vkCmdDraw, vkCmdDrawIndexed, vkCmdDrawIndirectCount, vkCmdDrawIndexedIndirectCount, vkCmdDrawIndirectCountKHR, vkCmdDrawIndexedIndirectCountKHR, vkCmdDrawIndirectCountAMD, vkCmdDrawIndexedIndirectCountAMD, vkCmdDrawMeshTasksNV, vkCmdDrawMeshTasksIndirectNV, vkCmdDrawMeshTasksIndirectCountNV, vkCmdDrawIndirect, and vkCmdDrawIndexedIndirect.

The duration of a Vulkan command refers to the interval between calling the command and its return to the caller.

A storage buffer whose offset is specified each time the storage buffer is bound to a command buffer via a descriptor set.

A uniform buffer whose offset is specified each time the uniform buffer is bound to a command buffer via a descriptor set.

See Dynamically Uniform in section 2.2 “Terms” of the Khronos SPIR-V Specification.

Arrays are composed of multiple elements, where each element exists at a unique index within that array. Used primarily to describe data passed to or returned from the Vulkan API.

A layer enabled by the application by adding it to the enabled layer list in vkCreateInstance or vkCreateDevice.

A synchronization primitive that is signaled when execution of previous commands complete through a specified set of pipeline stages. Events can be waited on by the device and polled by the host. Represented by a VkEvent object.

A command buffer that has ended recording commands and can be executed. See also Initial State and Recording State.

A dependency that guarantees that certain pipeline stages’ work for a first set of commands has completed execution before certain pipeline stages’ work for a second set of commands begins execution. This is accomplished via pipeline barriers, subpass dependencies, events, or implicit ordering operations.

A sequence of execution dependencies that transitively act as a single execution dependency.

An implementation of sampler Y′C_BC_R conversion which reconstructs reduced-resolution chroma samples to luma resolution and then separately performs texture sample interpolation. This is distinct from an implicit implementation, which incorporates chroma sample reconstruction into texture sample interpolation.

The set of objects and commands that can be affected by an extension. Extensions are either device scope or instance scope.

A structure type which may appear in the pNext chain of another structure, extending the functionality of the other structure. Extending structures may be defined by either core API versions or extensions.

A resource handle which has meaning outside of a specific Vulkan device or its parent instance. External handles may be used to share resources between multiple Vulkan devices in different instances, or between Vulkan and other APIs. Some external handle types correspond to platform-defined handles, in which case the resource may outlive any particular Vulkan device or instance and may be transferred between processes, or otherwise manipulated via functionality defined by the platform for that handle type.

A type of synchronization required of the application, where parameters defined to be externally synchronized must not be used simultaneously in multiple threads.

A classification of a polygon as either front-facing or back-facing, depending on the orientation (winding order) of its vertices.

A fragment is either front-facing or back-facing, depending on the primitive it was generated from. If the primitive was a polygon (regardless of polygon mode), the fragment inherits the facingness of the polygon. All other fragments are front-facing.

A synchronization primitive that is signaled when a set of batches or sparse binding operations complete execution on a queue. Fences can be waited on by the host. Represented by a VkFence object.

A property of a vertex attribute that causes the value from a single vertex (the provoking vertex) to be used for all vertices in a primitive, and for interpolation of that attribute to return that single value unaltered.

A set of features from VkFormatFeatureFlagBits that a VkFormat is capable of using for various commands. The list is determined by factors such as VkImageTiling.

A rectangular framebuffer region with associated data produced by rasterization and processed by fragment operations including the fragment shader.

The width and height, in pixels, of a fragment.

The ratio of fragments per framebuffer area in the x and y direction.

The (w,h) framebuffer region in pixels that each texel in a fragment density map applies to.

Variables with UniformConstant storage class and a decoration of InputAttachmentIndex that are statically used by a fragment shader’s entry point, which receive values from input attachments.

A lookup table that associates color samples with color fragment values.

A fragment shader entry point’s variables with Output storage class, which output to color and/or depth/stencil attachments.

A collection of image views and a set of dimensions that, in conjunction with a render pass, define the inputs and outputs used by drawing commands. Represented by a VkFramebuffer object.

One of the image views used in a framebuffer.

A coordinate system in which adjacent pixels’ coordinates differ by 1 in x and/or y, with (0,0) in the upper left corner and pixel centers at half-integers.

Operating with respect to framebuffer coordinates.

A framebuffer-local dependency guarantees that only for a single framebuffer region, the first set of operations happens-before the second set of operations.

A framebuffer-global dependency guarantees that for all framebuffer regions, the first set of operations happens-before the second set of operations.

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

See Facingness.

A collection of local workgroups dispatched by a single dispatch command. In addition to the compute dispatch, a single mesh task draw command can also generate such a collection.

An opaque integer or pointer value used to refer to a Vulkan object. Each object type has a unique handle type.

A transitive, irreflexive and antisymmetric ordering relation between operations. An execution dependency with a source of A and a destination of B enforces that B happens-after A. The inverse relation of happens-before.

A transitive, irreflexive and antisymmetric ordering relation between operations. An execution dependency with a source of A and a destination of B enforces that A happens-before B. The inverse relation of happens-after.

A fragment shader invocation that is created solely for the purposes of evaluating derivatives for use in non-helper fragment shader invocations, and which does not have side effects.

The processor(s) and execution environment that the application runs on, and that the Vulkan API is exposed on.

Device memory that is mapped for host access using vkMapMemory.

Memory owned by a foreign device that is mapped for host access.

Memory not accessible to the device, used to store implementation data structures.

A buffer, or a linear image subresource in either the VK_IMAGE_LAYOUT_PREINITIALIZED or VK_IMAGE_LAYOUT_GENERAL layout. Host-accessible subresources have a well-defined addressing scheme which can be used by the host.

Memory that is not local to the device, and may be less performant for device access than device-local memory.

Device memory that can be mapped on the host and can be read and written by the host.

Objects of the same type where all arguments to their creation or allocation functions, with the exception of pAllocator, are

A resource that represents a multi-dimensional formatted interpretation of device memory. Represented by a VkImage object.

A specific mipmap level and layer of an image.

A set of image subresources that are contiguous mipmap levels and layers.

An object that represents an image subresource range of a specific image, and state that controls how the contents are interpreted. Represented by a VkImageView object.

A sampler descriptor provided at descriptor set layout creation time, and that is used for that binding in all descriptor sets allocated from the layout, and cannot be changed.

An implementation of sampler Y′C_BC_R conversion which reconstructs the reduced-resolution chroma samples directly at the sample point, as part of the normal texture sampling operation. This is distinct from an explicit chroma reconstruction implementation, which reconstructs the reduced-resolution chroma samples to the resolution of the luma samples, then filters the result as part of texture sample interpolation.

A layer enabled by a loader-defined mechanism outside the Vulkan API, rather than explicitly by the application during instance or device creation.

A primitive or instance in a ray tracing acceleration structure which has a corresponding ID, but which will never report an intersection with any ray.

A buffer bound via vkCmdBindIndexBuffer which is the source of index values used to fetch vertex attributes for a vkCmdDrawIndexed or vkCmdDrawIndexedIndirect command.

Drawing commands which use an index buffer as the source of index values used to fetch vertex attributes for a drawing command. Includes vkCmdDrawIndexed, vkCmdDrawIndexedIndirectCount, vkCmdDrawIndexedIndirectCountKHR, vkCmdDrawIndexedIndirectCountAMD, and vkCmdDrawIndexedIndirect.

Drawing or dispatching commands that source some of their parameters from structures in buffer memory. Includes vkCmdDrawIndirect, vkCmdDrawIndexedIndirect, vkCmdDrawIndirectCount, vkCmdDrawIndexedIndirectCount, vkCmdDrawIndirectCountKHR, vkCmdDrawIndexedIndirectCountKHR, vkCmdDrawIndirectCountAMD, vkCmdDrawIndexedIndirectCountAMD, vkCmdDrawMeshTasksIndirectNV, vkCmdDrawMeshTasksIndirectCountNV, and vkCmdDispatchIndirect.

A definition of a sequence of commands, that are generated on the device via vkCmdPreprocessGeneratedCommandsNV and vkCmdExecuteGeneratedCommandsNV. Each sequence is comprised of multiple VkIndirectCommandsTokenTypeNV, which represent a subset of traditional command buffer commands. Represented as VkIndirectCommandsLayoutNV.

Drawing commands that source some of their parameters from structures in buffer memory. Includes vkCmdDrawIndirect, vkCmdDrawIndirectCount, vkCmdDrawIndexedIndirectCount, vkCmdDrawIndirectCountKHR, vkCmdDrawIndexedIndirectCountKHR, vkCmdDrawIndirectCountAMD, vkCmdDrawIndexedIndirectCountAMD, vkCmdDrawMeshTasksIndirectNV, vkCmdDrawMeshTasksIndirectCountNV, and vkCmdDrawIndexedIndirect.

A command buffer that has not begun recording commands. See also Recorded State and Executable State.

A descriptor type that represents uniform data stored directly in descriptor sets, and supports read-only access in a shader.

A descriptor type that represents an image view, and supports unfiltered read-only access in a shader, only at the fragment’s location in the view.

The top-level Vulkan object, which represents the application’s connection to the implementation. Represented by a VkInstance object.

Any command that is dispatched from an instance, or from a child object of an instance, except for physical devices and their children.

All instance-level commands and objects, and their structures, enumerated types, and enumerants.

High-level Vulkan objects, which are not physical devices, nor children of physical devices. For example, VkInstance is an instance-level object.

In a logical device representing more than one physical device, some device memory allocations have the requested amount of memory allocated multiple times, once for each physical device in a device mask. Each such replicated allocation is an instance of the device memory.

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.

A type of synchronization required of the implementation, where parameters not defined to be externally synchronized may require internal mutexing to avoid multithreaded race conditions.

A single execution of an entry point in a SPIR-V module. For example, a single vertex’s execution of a vertex shader or a single fragment’s execution of a fragment shader.

A set of shader invocations that are executed in parallel and that must execute the same control flow path in order for control flow to be considered dynamically uniform.

A ray tracing shader call instruction where the implementation may change the set of invocations that are executing.

The act of instructing a thread to participate in the execution of a deferred operation. See Deferred Host Operations.

A resource is linear if it is one of the following:

A 64-bit, vendor-prefixed, semi-opaque unsigned integer describing vendor-specific details of an image’s memory layout. In Linux graphics APIs, modifiers are commonly used to specify the memory layout of externally shared images. An image has a modifier if and only if it is created with tiling equal to VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT. For more details, refer to the appendix for extension VK_EXT_image_drm_format_modifier.

A collection of compute shader invocations invoked by a single dispatch command, which share data via WorkgroupLocal variables and can synchronize with each other.

An object that represents the application’s interface to the physical device. The logical device is the parent of most Vulkan objects. Represented by a VkDevice object.

Bitwise operations between a fragment color value and a value in a color attachment, that produce a final color value to be written to the attachment.

A state that a logical device may be in as a result of unrecoverable implementation errors, or other exceptional conditions.

See Host-Visible Memory.

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

A memory domain is an abstract place to which memory writes are made available by availability operations and memory domain operations. The memory domains correspond to the set of agents that the write can then be made visible to. The memory domains are host, device, shader, workgroup instance (for workgroup instance there is a unique domain for each compute workgroup) and subgroup instance (for subgroup instance there is a unique domain for each subgroup).

An operation that makes the writes that are available to one memory domain available to another memory domain.

A region of memory from which device memory allocations can be made.

An index used to select a set of memory properties (e.g. mappable, cached) for a device memory allocation.

A graphics pipeline where the primitives are assembled explicitly in the shader stages. In contrast to the primitive shading pipeline where input primitives are assembled by fixed function processing.

Drawing commands which create shader invocations organized in workgroups for drawing mesh tasks. Includes vkCmdDrawMeshTasksNV, vkCmdDrawMeshTasksIndirectNV, and vkCmdDrawMeshTasksIndirectCountNV.

The smallest size that is permitted for a miplevel. For conventional images this is 1x1x1. For corner-sampled images, this is 2x2x2. See Image Miplevel Sizing.

The set of mipmap levels of a sparse residency texture that are too small to fill a sparse block, and that must all be bound to memory collectively and opaquely.

A multi-planar format (or “planar format”) is an image format consisting of more than one plane, identifiable with a _2PLANE or _3PLANE component to the format name and listed in Formats requiring sampler Y′C_BC_R conversion for VK_IMAGE_ASPECT_COLOR_BIT image views. A multi-planar image (or “planar image”) is an image of a multi-planar format.

A handle of an integer handle type. Handle values may not be unique, even for two objects of the same type.

Drawing commands for which the vertex attributes are sourced in linear order from the vertex input attributes for a drawing command (i.e. they do not use an index buffer). Includes vkCmdDraw, vkCmdDrawIndirectCount, vkCmdDrawIndirectCountKHR, vkCmdDrawIndirectCountAMD, and vkCmdDrawIndirect.

A value that is interpreted as being in the range [0,1] as a result of being implicitly divided by some other value.

A coordinate space after perspective division is applied to clip coordinates, and before the viewport transformation converts to framebuffer coordinates.

A feature is obsolete if it can no longer be used.

A 64-bit value representing the device address of a buffer or memory object that is expected to be used by trace capture/replay tools in combination with the bufferDeviceAddress feature.

The aliased range of a device memory allocation that intersects a given image subresource of an image or range of a buffer.

If an entity (e.g. a queue family) has ownership of a resource, access to that resource is well-defined for access by that entity.

A format whose components are stored as a single texel block in memory, with their relative locations defined within that element.

A geometry shader which uses the PassthroughNV decoration on a variable in its input interface. Output primitives in a passthrough geometry shader always have the same topology as the input primitive and are not produced by emitting vertices.

Importable or exportable reference to the internal data of an object in Vulkan.

A variable that has an array of values which are output, one for each view that is being generated. A mesh shader which uses the PerViewNV decoration on a variable in its output interface.

An instance of memory corresponding to a different physical device than the physical device performing the memory access, in a logical device that represents multiple physical devices.

An object that represents a single device in the system. Represented by a VkPhysicalDevice object.

Any command that is dispatched from a physical device.

All physical-device-level commands and objects, and their structures, enumerated types, and enumerants.

Physical device objects. For example, VkPhysicalDevice is a physical-device-level object.

An object that controls how graphics or compute work is executed on the device. A pipeline includes one or more shaders, as well as state controlling any non-programmable stages of the pipeline. Represented by a VkPipeline object.

An execution and/or memory dependency recorded as an explicit command in a command buffer, that forms a dependency between the previous and subsequent commands.

An object that can be used to collect and retrieve information from pipelines as they are created, and can be populated with previously retrieved information in order to accelerate pipeline creation. Represented by a VkPipelineCache object.

An object that defines the set of resources (via a collection of descriptor set layouts) and push constants used by pipelines that are created using the layout. Used when creating a pipeline and when binding descriptor sets and setting push constant values. Represented by a VkPipelineLayout object.

A pipeline that cannot be directly used, instead defining a set of shaders and shader groups which will be linked into other pipelines.

A logically independent execution unit that performs some of the operations defined by an action command.

A set of structures chained together through their pNext members.

See multi-planar.

An image plane is part of the representation of an image, containing a subset of the color channels required to represent the texels in the image and with a contiguous mapping of coordinates to bound memory. Most images consist only of a single plane, but some formats spread the channels across multiple image planes. The host-accessible properties of each image plane are accessed in a linear layout using vkGetImageSubresourceLayout. If a multi-planar image is created with the VK_IMAGE_CREATE_DISJOINT_BIT bit set, the image is described as disjoint, and its planes are therefore are bound to memory independently.

A rule that determines whether a fragment sample location is covered by a polygon primitive by testing whether the sample location is in the interior of the polygon in framebuffer-space, or on the boundary of the polygon according to the tie-breaking rules.

The union of all VkFormatFeatureFlagBits that the implementation supports for a specified VkFormat, over all supported image tilings. For external formats the VkFormatFeatureFlagBits is provided by the implementation.

A VkImage object obtained from a VkSwapchainKHR used to present to a VkSurfaceKHR object.

One of a list of attachments in a subpass description that is not read or written by the subpass, but that is read or written on earlier and later subpasses and whose contents must be preserved through this subpass.

A command buffer that can execute secondary command buffers, and can be submitted directly to a queue.

A graphics pipeline where input primitives are assembled by fixed function processing. It is the counterpart to mesh shading.

State that controls how vertices are assembled into primitives, e.g. as lists of triangles, strips of lines, etc..

A feature from an older extension is considered promoted if it is made available as part of a new core version or newer extension with wider support.

A buffer to which protected device memory can be bound.

A device queue to which protected command buffers can be submitted.

A command buffer which can be submitted to a protected-capable device queue.

Device memory which can be visible to the device but must not be visible to the host.

An image to which protected device memory can be bound.

A feature is released provisionally in order to get wider feedback on the functionality before it is finalized. Provisional features may change in ways that break backwards compatibility, and thus are not recommended for use in production applications.

The vertex in a primitive from which flat shaded attribute values are taken. This is generally the “first” vertex in the primitive, and depends on the primitive topology.

A small bank of values writable via the API and accessible in shaders. Push constants allow the application to set values used in shaders without creating buffers or modifying and binding descriptor sets for each update.

The set of variables with PushConstant storage class that are statically used by a shader entry point, and which receive values from push constant commands.

Descriptors that are written directly into a command buffer rather than into a descriptor set. Push descriptors allow the application to set descriptors used in shaders without allocating or modifying descriptor sets for each update.

An object that specifies a mapping from descriptor update information in host memory to elements in a descriptor set, which helps enable more efficient descriptor set updates.

An object containing a number of query entries and their associated state and results. Represented by a VkQueryPool object.

An object that executes command buffers and sparse binding operations on a device. Represented by a VkQueue object.

A set of queues that have common properties and support the same functionality, as advertised in VkQueueFamilyProperties.

A unit of work to be executed by a specific queue on a device, submitted via a queue submission command. Each queue submission command details the specific queue operations that occur as a result of calling that command. Queue operations typically include work that is specific to each command, and synchronization tasks.

Zero or more batches and an optional fence to be signaled, passed to a command for execution on a queue. See the Devices and Queues chapter for more information.

A command buffer that is ready to record commands. See also Initial State and Executable State.

An operation that releases ownership of an image subresource or buffer range.

An object that represents a set of framebuffer attachments and phases of rendering using those attachments. Represented by a VkRenderPass object.

A use of a render pass in a command buffer.

Extensions that must be enabled alongside extensions dependent on them (see Extension Dependencies).

Resetting a command buffer discards any previously recorded commands and puts a command buffer in the initial state.

An integer value returned by sparse image instructions, indicating whether any sparse unbound texels were accessed.

A subpass attachment point, or image view, that is the target of a multisample resolve operation from the corresponding color attachment at the end of the subpass.

A swapchain that has been used as the oldSwapchain parameter to vkCreateSwapchainKHR. Images cannot be acquired from a retired swapchain, however images that were acquired (but not presented) before the swapchain was retired can be presented.

The index of a sample within a single set of samples.

Invoking the fragment shader multiple times per fragment, with the covered samples partitioned among the invocations.

A descriptor type that represents an image view, and supports filtered (sampled) and unfiltered read-only access in a shader.

An object containing state that controls how sampled image data is sampled (or filtered) when accessed in a shader. Also a descriptor type describing the object. Represented by a VkSampler object.

A command buffer that can be executed by a primary command buffer, and must not be submitted directly to a queue.

A subpass dependency from a subpass to itself, i.e. with srcSubpass equal to dstSubpass. A self-dependency is not automatically performed during a render pass instance, rather a subset of it can be performed via vkCmdPipelineBarrier during the subpass.

A synchronization primitive that supports signal and wait operations, and can be used to synchronize operations within a queue or across queues. Represented by a VkSemaphore object.

Instructions selected (via an entry point) from a shader module, which are executed in a shader stage.

An instruction which may cause execution to continue in a different shader stage.

A stream of instructions used to describe the operation of a shader.

A set of Shader Stages that are part of a VkPipeline which contains multiple of such sets. This allows the device to make use of all the shader groups from the bound pipeline independently.

A collection of shader code, potentially including several functions and entry points, that is used to create shaders in pipelines. Represented by a VkShaderModule object.

A stage of the graphics or compute pipeline that executes shader code.

The ratio of the number of fragment shader invocations generated in a fully covered framebuffer region to the size (in pixels) of that region.

An image used to establish the shading rate for a framebuffer region, where each pixel controls the shading rate for a corresponding framebuffer region.

A presentable image created from a swapchain with VkPresentModeKHR set to either VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR or VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR.

A store to memory or atomic operation on memory from a shader invocation.

A format that is not multi-planar.

When a compressed image format and an uncompressed image format are size-compatible, it means that the texel block size of the uncompressed format must equal the texel block size of the compressed format.

An element of a sparse resource that can be independently bound to memory. Sparse blocks of a particular sparse resource have a corresponding size in bytes that they use in the bound memory.

A sparse block in a sparse partially-resident image. In addition to the sparse block size in bytes, sparse image blocks have a corresponding width, height, and depth that define the dimensions of these elements in units of texels or compressed texel blocks, the latter being used in case of sparse images having a block-compressed format.

A texel read from a region of a sparse texture that does not have memory bound to it.

An object in a shader is statically used by a shader entry point if any function in the entry point’s call tree contains an instruction using the object. Static use is used to constrain the set of descriptors used by a shader entry point.

A descriptor type that represents a buffer, and supports reads, writes, and atomics in a shader.

A descriptor type that represents an image view, and supports unfiltered loads, stores, and atomics in a shader.

A descriptor type that represents a buffer view, and supports unfiltered, formatted reads, writes, and atomics in a shader.

A set of shader invocations that can synchronize and share data with each other efficiently. In compute shaders, the local workgroup is a superset of the subgroup.

A bitmask for all invocations in the current subgroup with one bit per invocation, starting with the least significant bit in the first vector component, continuing to the last bit (less than SubgroupSize) in the last required vector component.

A phase of rendering within a render pass, that reads and writes a subset of the attachments.

An execution and/or memory dependency between two subpasses described as part of render pass creation, and automatically performed between subpasses in a render pass instance. A subpass dependency limits the overlap of execution of the pair of subpasses, and can provide guarantees of memory coherence between accesses in the subpasses.

Lists of attachment indices for input attachments, color attachments, depth/stencil attachment, resolve attachments, depth/stencil resolve, and preserve attachments used by the subpass in a render pass.

A subset of a self-dependency is a pipeline barrier performed during the subpass of the self-dependency, and whose stage masks and access masks each contain a subset of the bits set in the identically named mask in the self-dependency.

A single addressable element of an image with an uncompressed VkFormat, or a single compressed block of an image with a compressed VkFormat.

The size (in bytes) used to store a texel block of a compressed or uncompressed image.

One of three coordinate systems (normalized, unnormalized, integer) that define how texel coordinates are interpreted in an image or a specific mipmap level of an image.

A semaphore with a monotonically increasing 64-bit unsigned integer payload indicating whether the semaphore is signaled with respect to a particular reference value. Represented by a VkSemaphore object created with a semaphore type of VK_SEMAPHORE_TYPE_TIMELINE.

A descriptor type that represents a buffer view, and supports unfiltered, formatted, read-only access in a shader.

A descriptor type that represents a buffer, and supports read-only access in a shader.

A measure of floating-point error loosely defined as the smallest representable step in a floating-point format near a given value. For the precise definition see Precision and Operation of SPIR-V instructions or Jean-Michel Muller, “On the definition of ulp(x)”, RR-5504, INRIA. Other sources may also use the term “unit of least precision”.

A value that is interpreted according to its conventional interpretation, and is not normalized.

A buffer to which unprotected device memory can be bound.

A command buffer which can be submitted to an unprotected device queue or a protected-capable device queue.

Device memory which can be visible to the device and can be visible to the host.

An image to which unprotected device memory can be bound.

A shader entry point’s variables with Input or Output storage class that are not built-in variables.

A graphics pipeline resource that produces input values for the vertex shader by reading data from a vertex input binding and converting it to the attribute’s format.

A vertex stream is where the last vertex processing stage outputs vertex data, which then goes to the rasterizer, is captured to a transform feedback buffer, or both. 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.

An object that can be used to collect and retrieve validation results from the validation layers, and can be populated with previously retrieved results in order to accelerate the validation process. Represented by a VkValidationCacheEXT object.

A graphics pipeline resource that is bound to a buffer and includes state that affects addressing calculations within that buffer.

A vertex shader entry point’s variables with Input storage class, which receive values from vertex input attributes.

A set of shader stages that comprises the vertex shader, tessellation control shader, tessellation evaluation shader, and geometry shader stages. The task and mesh shader stages also belong to this group.

When multiview is enabled, a view mask is a property of a subpass controlling which views the rendering commands are broadcast to.

A subspace in homogeneous coordinates, corresponding to post-projection x and y values between -1 and +1, and z values between 0 and +1.

A transformation from normalized device coordinates to framebuffer coordinates, based on a viewport rectangle and depth range.

An operation that causes available values to become visible to specified memory accesses.

A state of values written to memory that allows them to be accessed by a set of operations.