1428 lines
54 KiB
Plaintext
1428 lines
54 KiB
Plaintext
// Copyright (c) 2015-2018 Khronos Group. This work is licensed under a
|
|
// Creative Commons Attribution 4.0 International License; see
|
|
// http://creativecommons.org/licenses/by/4.0/
|
|
|
|
// The asciidoc [glossary] template cannot contain subsections.
|
|
// The abbreviations and prefixes probably belong in the upcoming
|
|
// API/extension-writing-guidelines appendix, anyway.
|
|
|
|
[glossary]
|
|
[[glossary]]
|
|
= Glossary
|
|
|
|
The terms defined in this section are used consistently throughout this
|
|
Specification and may be used with or without capitalization.
|
|
|
|
Accessible (Descriptor Binding)::
|
|
A descriptor binding is accessible to a shader stage if that stage is
|
|
included in the pname:stageFlags of the descriptor binding.
|
|
Descriptors using that binding can: only be used by stages in which they
|
|
are accessible.
|
|
|
|
Acquire Operation (Resource)::
|
|
An operation that acquires ownership of an image subresource or buffer
|
|
range.
|
|
|
|
Adjacent Vertex::
|
|
A vertex in an adjacency primitive topology that is not part of a given
|
|
primitive, but is accessible in geometry shaders.
|
|
|
|
ifdef::VK_EXT_blend_operation_advanced[]
|
|
Advanced Blend Operation::
|
|
Blending performed using one of the blend operation enums introduced by
|
|
the `<<VK_EXT_blend_operation_advanced>>` extension.
|
|
See <<framebuffer-blend-advanced, Advanced Blending Operations>>.
|
|
endif::VK_EXT_blend_operation_advanced[]
|
|
|
|
Aliased Range (Memory)::
|
|
A range of a device memory allocation that is bound to multiple
|
|
resources simultaneously.
|
|
|
|
Allocation Scope::
|
|
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.
|
|
|
|
Aspect (Image)::
|
|
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.
|
|
|
|
Attachment (Render Pass)::
|
|
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.
|
|
|
|
Availability Operation::
|
|
An operation that causes the values generated by specified memory write
|
|
accesses to become available for future access.
|
|
|
|
Available::
|
|
A state of values written to memory that allows them to be made visible.
|
|
|
|
Back-Facing::
|
|
See Facingness.
|
|
|
|
Batch::
|
|
A single structure submitted to a queue as part of a
|
|
<<devsandqueues-submission, queue submission command>>, describing a set
|
|
of queue operations to execute.
|
|
|
|
Backwards Compatibility::
|
|
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.
|
|
|
|
Full Compatibility::
|
|
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.
|
|
|
|
Binding (Memory)::
|
|
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 flink:vkBindBufferMemory
|
|
command for non-sparse buffer objects, using the flink:vkBindImageMemory
|
|
command for non-sparse image objects, and using the
|
|
flink:vkQueueBindSparse command for sparse resources.
|
|
|
|
Blend Constant::
|
|
Four floating point (RGBA) values used as an input to blending.
|
|
|
|
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.
|
|
|
|
Buffer::
|
|
A resource that represents a linear array of data in device memory.
|
|
Represented by a slink:VkBuffer object.
|
|
|
|
Buffer View::
|
|
An object that represents a range of a specific buffer, and state that
|
|
controls how the contents are interpreted.
|
|
Represented by a slink:VkBufferView object.
|
|
|
|
Built-In Variable::
|
|
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.
|
|
|
|
Built-In Interface Block::
|
|
A block defined in a shader that contains only variables decorated with
|
|
built-in decorations, and is used to match against other shader stages.
|
|
|
|
Clip Coordinates::
|
|
The homogeneous coordinate space that vertex positions (code:Position
|
|
decoration) are written in by vertex processing stages.
|
|
|
|
Clip Distance::
|
|
A built-in output from vertex processing stages that defines a clip
|
|
half-space against which the primitive is clipped.
|
|
|
|
Clip Volume::
|
|
The intersection of the view volume with all clip half-spaces.
|
|
|
|
Color Attachment::
|
|
A subpass attachment point, or image view, that is the target of
|
|
fragment color outputs and blending.
|
|
|
|
ifdef::VK_AMD_shader_fragment_mask[]
|
|
Color Fragment::
|
|
A unique color value within a pixel of a multisampled color image.
|
|
The _fragment mask_ will contain indices to the _color fragment_.
|
|
endif::VK_AMD_shader_fragment_mask[]
|
|
|
|
Color Renderable Format::
|
|
A elink:VkFormat where ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT is
|
|
set in the pname:optimalTilingFeatures or pname:linearTilingFeatures
|
|
member of slink:VkFormatProperties returned by
|
|
flink:vkGetPhysicalDeviceFormatProperties, depending on the tiling used.
|
|
|
|
Color Sample Mask::
|
|
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.
|
|
|
|
Combined Image Sampler::
|
|
A descriptor type that includes both a sampled image and a sampler.
|
|
|
|
Command Buffer::
|
|
An object that records commands to be submitted to a queue.
|
|
Represented by a slink:VkCommandBuffer object.
|
|
|
|
Command Pool::
|
|
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 slink:VkCommandPool object.
|
|
|
|
Compatible Allocator::
|
|
When allocators are compatible, allocations from each allocator can: be
|
|
freed by the other allocator.
|
|
|
|
Compatible Image Formats::
|
|
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_.
|
|
|
|
Compatible Queues::
|
|
Queues within a queue family.
|
|
Compatible queues have identical properties.
|
|
|
|
Component (Format)::
|
|
A distinct part of a format.
|
|
Depth, stencil, and color channels (e.g. R, G, B, A), are all separate
|
|
components.
|
|
|
|
Compressed Texel Block::
|
|
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.
|
|
|
|
Coverage::
|
|
A bitfield associated with a fragment, where each bit is associated to a
|
|
rasterization sample.
|
|
Samples are initially considered to be covered based on the result of
|
|
rasterization, and then coverage can subsequently be turned on or off by
|
|
other fragment operations or the fragment shader.
|
|
Uncovered samples do not write to framebuffer attachments.
|
|
|
|
Cull Distance::
|
|
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.
|
|
|
|
Cull Volume::
|
|
The intersection of the view volume with all cull half-spaces.
|
|
|
|
Decoration (SPIR-V)::
|
|
Auxiliary information such as built-in variables, stream numbers,
|
|
invariance, interpolation type, relaxed precision, etc., added to
|
|
variables or structure-type members through decorations.
|
|
|
|
Deprecated::
|
|
A feature is deprecated if it is no longer recommended as the correct or
|
|
best way to achieve its intended purpose.
|
|
Generally a newer feature will have been created that solves the same
|
|
problem - in cases where no newer alternative feature exists,
|
|
justification should be provided.
|
|
|
|
Depth/Stencil Attachment::
|
|
A subpass attachment point, or image view, that is the target of depth
|
|
and/or stencil test operations and writes.
|
|
|
|
Depth/Stencil Format::
|
|
A elink:VkFormat that includes depth and/or stencil components.
|
|
|
|
Depth/Stencil Image (or ImageView)::
|
|
A slink:VkImage (or slink:VkImageView) with a depth/stencil format.
|
|
|
|
Derivative Group::
|
|
A set of fragment shader invocations that cooperate to compute
|
|
derivatives, including implicit derivatives for sampled image
|
|
operations.
|
|
|
|
Descriptor::
|
|
Information about a resource or resource view written into a descriptor
|
|
set that is used to access the resource or view from a shader.
|
|
|
|
Descriptor Binding::
|
|
An entry in a descriptor set layout corresponding to zero or more
|
|
descriptors of a single descriptor type in a set.
|
|
Defined by a slink:VkDescriptorSetLayoutBinding structure.
|
|
|
|
Descriptor Pool::
|
|
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 slink:VkDescriptorPool object.
|
|
|
|
Descriptor Set::
|
|
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 slink:VkDescriptorSet object.
|
|
|
|
Descriptor Set Layout::
|
|
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 slink:VkDescriptorSetLayout object.
|
|
|
|
Device::
|
|
The processor(s) and execution environment that perform tasks requested
|
|
by the application via the Vulkan API.
|
|
|
|
ifdef::VK_VERSION_1_1,VK_KHR_device_group_creation[]
|
|
Device Group::
|
|
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 Index::
|
|
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.
|
|
|
|
Device Mask::
|
|
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.
|
|
endif::VK_VERSION_1_1,VK_KHR_device_group_creation[]
|
|
|
|
Device Memory::
|
|
Memory accessible to the device.
|
|
Represented by a slink:VkDeviceMemory object.
|
|
|
|
Device-Level Command::
|
|
Any command that is dispatched from a logical device, or from a child
|
|
object of a logical device.
|
|
|
|
Device-Level Functionality::
|
|
All device-level commands and objects, and their structures, enumerated
|
|
types, and enumerants.
|
|
|
|
Device-Level Object::
|
|
Logical device objects and their child objects.
|
|
For example, slink:VkDevice, slink:VkQueue, and slink:VkCommandBuffer
|
|
objects are device-level objects.
|
|
|
|
Device-Local Memory::
|
|
Memory that is connected to the device, and may: be more performant for
|
|
device access than host-local memory.
|
|
|
|
Direct Drawing Commands::
|
|
_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 flink:vkCmdDraw, and flink:vkCmdDrawIndexed.
|
|
|
|
ifdef::VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion[]
|
|
Disjoint::
|
|
_Disjoint planes_ are _image planes_ to which memory is bound
|
|
independently. +
|
|
A _disjoint image_ consists of multiple _disjoint planes_, and is
|
|
created with the ename:VK_IMAGE_CREATE_DISJOINT_BIT bit set.
|
|
endif::VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion[]
|
|
|
|
Dispatchable Handle::
|
|
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.
|
|
|
|
Dispatching Commands::
|
|
Commands that provoke work using a compute pipeline.
|
|
Includes flink:vkCmdDispatch and flink:vkCmdDispatchIndirect.
|
|
|
|
Drawing Commands::
|
|
Commands that provoke work using a graphics pipeline.
|
|
Includes flink:vkCmdDraw, flink:vkCmdDrawIndexed,
|
|
flink:vkCmdDrawIndirect,
|
|
ifdef::VK_KHR_draw_indirect_count[]
|
|
flink:vkCmdDrawIndirectCountKHR, flink:vkCmdDrawIndexedIndirectCountKHR,
|
|
endif::VK_KHR_draw_indirect_count[]
|
|
ifdef::VK_AMD_draw_indirect_count[]
|
|
flink:vkCmdDrawIndirectCountAMD, flink:vkCmdDrawIndexedIndirectCountAMD,
|
|
endif::VK_AMD_draw_indirect_count[]
|
|
and flink:vkCmdDrawIndexedIndirect.
|
|
|
|
Duration (Command)::
|
|
The _duration_ of a Vulkan command refers to the interval between
|
|
calling the command and its return to the caller.
|
|
|
|
Dynamic Storage Buffer::
|
|
A storage buffer whose offset is specified each time the storage buffer
|
|
is bound to a command buffer via a descriptor set.
|
|
|
|
Dynamic Uniform Buffer::
|
|
A uniform buffer whose offset is specified each time the uniform buffer
|
|
is bound to a command buffer via a descriptor set.
|
|
|
|
Dynamically Uniform::
|
|
See _Dynamically Uniform_ in section 2.2 "`Terms`" of the
|
|
<<spirv-spec,Khronos SPIR-V Specification>>.
|
|
|
|
Element Size::
|
|
The size (in bytes) used to store one element of an uncompressed format
|
|
or the size (in bytes) used to store one block of a block-compressed
|
|
format.
|
|
|
|
Explicitly-Enabled Layer::
|
|
A layer enabled by the application by adding it to the enabled layer
|
|
list in flink:vkCreateInstance or flink:vkCreateDevice.
|
|
|
|
Event::
|
|
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 slink:VkEvent object.
|
|
|
|
Executable State (Command Buffer)::
|
|
A command buffer that has ended recording commands and can: be executed.
|
|
See also Initial State and Recording State.
|
|
|
|
Execution Dependency::
|
|
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.
|
|
|
|
Execution Dependency Chain::
|
|
A sequence of execution dependencies that transitively act as a single
|
|
execution dependency.
|
|
|
|
ifdef::VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion[]
|
|
Explicit chroma reconstruction::
|
|
An implementation of sampler Y'C~B~C~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.
|
|
endif::VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion[]
|
|
|
|
Extension Scope::
|
|
The set of objects and commands that can: be affected by an extension.
|
|
Extensions are either device scope or instance scope.
|
|
|
|
ifdef::VK_VERSION_1_1,VK_KHR_external_memory_capabilities,VK_KHR_external_semaphore_capabilities,VK_KHR_external_fence_capabilities[]
|
|
External Handle::
|
|
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.
|
|
endif::VK_VERSION_1_1,VK_KHR_external_memory_capabilities,VK_KHR_external_semaphore_capabilities,VK_KHR_external_fence_capabilities[]
|
|
|
|
External synchronization::
|
|
A type of synchronization required: of the application, where parameters
|
|
defined to be externally synchronized must: not be used simultaneously
|
|
in multiple threads.
|
|
|
|
Facingness (Polygon)::
|
|
A classification of a polygon as either front-facing or back-facing,
|
|
depending on the orientation (winding order) of its vertices.
|
|
|
|
Facingness (Fragment)::
|
|
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.
|
|
|
|
Fence::
|
|
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 slink:VkFence object.
|
|
|
|
Flat Shading::
|
|
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.
|
|
|
|
Fragment Input Attachment Interface::
|
|
Variables with code:UniformConstant storage class and a decoration of
|
|
code:InputAttachmentIndex that are statically used by a fragment
|
|
shader's entry point, which receive values from input attachments.
|
|
|
|
ifdef::VK_AMD_shader_fragment_mask[]
|
|
Fragment Mask::
|
|
A lookup table that associates color samples with color fragment values.
|
|
endif::VK_AMD_shader_fragment_mask[]
|
|
|
|
Fragment Output Interface::
|
|
A fragment shader entry point's variables with code:Output storage
|
|
class, which output to color and/or depth/stencil attachments.
|
|
|
|
Framebuffer::
|
|
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 slink:VkFramebuffer object.
|
|
|
|
Framebuffer Attachment::
|
|
One of the image views used in a framebuffer.
|
|
|
|
Framebuffer Coordinates::
|
|
A coordinate system in which adjacent pixels`' coordinates differ by 1
|
|
in x and/or y, with [eq]#(0,0)# in the upper left corner and pixel
|
|
centers at half-integers.
|
|
|
|
Framebuffer-Space::
|
|
Operating with respect to framebuffer coordinates.
|
|
|
|
Framebuffer-Local::
|
|
A framebuffer-local dependency guarantees that only for a single
|
|
framebuffer region, the first set of operations happens-before the
|
|
second set of operations.
|
|
|
|
Framebuffer-Global::
|
|
A framebuffer-global dependency guarantees that for all framebuffer
|
|
regions, the first set of operations happens-before the second set of
|
|
operations.
|
|
|
|
Framebuffer Region::
|
|
A framebuffer region is a set of sample (x, y, layer, sample)
|
|
coordinates that is a subset of the entire framebuffer.
|
|
|
|
Front-Facing::
|
|
See Facingness.
|
|
|
|
Global Workgroup::
|
|
A collection of local workgroups dispatched by a single dispatch
|
|
command.
|
|
|
|
Handle::
|
|
An opaque integer or pointer value used to refer to a Vulkan object.
|
|
Each object type has a unique handle type.
|
|
|
|
Happen-after::
|
|
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.
|
|
|
|
Happen-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.
|
|
|
|
Helper Invocation::
|
|
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.
|
|
|
|
Host::
|
|
The processor(s) and execution environment that the application runs on,
|
|
and that the Vulkan API is exposed on.
|
|
|
|
ifdef::VK_EXT_external_memory_host[]
|
|
Host Mapped Foreign Memory::
|
|
Memory owned by a foreign device that is mapped for host access.
|
|
endif::VK_EXT_external_memory_host[]
|
|
|
|
Host Memory::
|
|
Memory not accessible to the device, used to store implementation data
|
|
structures.
|
|
|
|
Host-Accessible Subresource::
|
|
A buffer, or a linear image subresource in either the
|
|
ename:VK_IMAGE_LAYOUT_PREINITIALIZED or ename:VK_IMAGE_LAYOUT_GENERAL
|
|
layout.
|
|
Host-accessible subresources have a well-defined addressing scheme which
|
|
can be used by the host.
|
|
|
|
Host-Local Memory::
|
|
Memory that is not local to the device, and may: be less performant for
|
|
device access than device-local memory.
|
|
|
|
Host-Visible Memory::
|
|
Device memory that can: be mapped on the host and can: be read and
|
|
written by the host.
|
|
|
|
Identically Defined Objects::
|
|
Objects of the same type where all arguments to their creation or
|
|
allocation functions, with the exception of pname:pAllocator, are +
|
|
. Vulkan handles which refer to the same object or
|
|
. identical scalar or enumeration values or
|
|
. Host pointers which point to an array of values or structures which
|
|
also satisfy these three constraints.
|
|
|
|
Image::
|
|
A resource that represents a multi-dimensional formatted interpretation
|
|
of device memory.
|
|
Represented by a slink:VkImage object.
|
|
|
|
Image Subresource::
|
|
A specific mipmap level and layer of an image.
|
|
|
|
Image Subresource Range::
|
|
A set of image subresources that are contiguous mipmap levels and
|
|
layers.
|
|
|
|
Image View::
|
|
An object that represents an image subresource range of a specific
|
|
image, and state that controls how the contents are interpreted.
|
|
Represented by a slink:VkImageView object.
|
|
|
|
Immutable Sampler::
|
|
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.
|
|
|
|
ifdef::VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion[]
|
|
Implicit chroma reconstruction::
|
|
An implementation of sampler Y'C~B~C~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.
|
|
endif::VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion[]
|
|
|
|
Implicitly-Enabled Layer::
|
|
A layer enabled by a loader-defined mechanism outside the Vulkan API,
|
|
rather than explicitly by the application during instance or device
|
|
creation.
|
|
|
|
Index Buffer::
|
|
A buffer bound via flink:vkCmdBindIndexBuffer which is the source of
|
|
index values used to fetch vertex attributes for a
|
|
flink:vkCmdDrawIndexed or flink:vkCmdDrawIndexedIndirect command.
|
|
|
|
Indexed Drawing Commands::
|
|
_Drawing commands_ which use an _index buffer_ as the source of index
|
|
values used to fetch vertex attributes for a drawing command.
|
|
Includes flink:vkCmdDrawIndexed,
|
|
ifdef::VK_KHR_draw_indirect_count[]
|
|
flink:vkCmdDrawIndexedIndirectCountKHR,
|
|
endif::VK_KHR_draw_indirect_count[]
|
|
ifdef::VK_AMD_draw_indirect_count[]
|
|
flink:vkCmdDrawIndexedIndirectCountAMD,
|
|
endif::VK_AMD_draw_indirect_count[]
|
|
and flink:vkCmdDrawIndexedIndirect.
|
|
|
|
Indirect Commands::
|
|
Drawing or dispatching commands that source some of their parameters
|
|
from structures in buffer memory.
|
|
Includes flink:vkCmdDrawIndirect, flink:vkCmdDrawIndexedIndirect,
|
|
ifdef::VK_KHR_draw_indirect_count[]
|
|
flink:vkCmdDrawIndirectCountKHR, flink:vkCmdDrawIndexedIndirectCountKHR,
|
|
endif::VK_KHR_draw_indirect_count[]
|
|
ifdef::VK_AMD_draw_indirect_count[]
|
|
flink:vkCmdDrawIndirectCountAMD, flink:vkCmdDrawIndexedIndirectCountAMD,
|
|
endif::VK_AMD_draw_indirect_count[]
|
|
and flink:vkCmdDispatchIndirect.
|
|
|
|
ifdef::VK_NVX_device_generated_commands[]
|
|
Indirect Commands Layout::
|
|
A definition of a sequence of commands, that are generated on the device
|
|
via flink:vkCmdProcessCommandsNVX.
|
|
Each sequence is comprised of multiple
|
|
elink:VkIndirectCommandsTokenTypeNVX, which represent a subset of
|
|
traditional command buffer commands.
|
|
Represented as slink:VkIndirectCommandsLayoutNVX.
|
|
endif::VK_NVX_device_generated_commands[]
|
|
|
|
Indirect Drawing Commands::
|
|
_Drawing commands_ that source some of their parameters from structures
|
|
in buffer memory.
|
|
Includes flink:vkCmdDrawIndirect,
|
|
ifdef::VK_KHR_draw_indirect_count[]
|
|
flink:vkCmdDrawIndirectCountKHR, flink:vkCmdDrawIndexedIndirectCountKHR,
|
|
endif::VK_KHR_draw_indirect_count[]
|
|
ifdef::VK_AMD_draw_indirect_count[]
|
|
flink:vkCmdDrawIndirectCountAMD, flink:vkCmdDrawIndexedIndirectCountAMD,
|
|
endif::VK_AMD_draw_indirect_count[]
|
|
and flink:vkCmdDrawIndexedIndirect.
|
|
|
|
Initial State (Command Buffer)::
|
|
A command buffer that has not begun recording commands.
|
|
See also Recorded State and Executable State.
|
|
|
|
ifdef::VK_EXT_inline_uniform_block[]
|
|
Inline Uniform Block::
|
|
A descriptor type that represents uniform data stored directly in
|
|
descriptor sets, and supports read-only access in a shader.
|
|
endif::VK_EXT_inline_uniform_block[]
|
|
|
|
Input Attachment::
|
|
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.
|
|
|
|
Instance::
|
|
The top-level Vulkan object, which represents the application's
|
|
connection to the implementation.
|
|
Represented by a slink:VkInstance object.
|
|
|
|
Instance-Level Command::
|
|
Any command that is dispatched from an instance, or from a child object
|
|
of an instance, except for physical devices and their children.
|
|
|
|
Instance-Level Functionality::
|
|
All instance-level commands and objects, and their structures,
|
|
enumerated types, and enumerants.
|
|
|
|
Instance-Level Object::
|
|
High-level Vulkan objects, which are not physical devices, nor children
|
|
of physical devices.
|
|
For example, slink:VkInstance is an instance-level object.
|
|
|
|
ifdef::VK_VERSION_1_1,VK_KHR_device_group[]
|
|
Instance (Memory)::
|
|
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.
|
|
|
|
Instance (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.
|
|
endif::VK_VERSION_1_1,VK_KHR_device_group[]
|
|
|
|
Internal Synchronization::
|
|
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.
|
|
|
|
Invocation (Shader)::
|
|
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.
|
|
|
|
Invocation Group::
|
|
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.
|
|
|
|
[[glossary-linear-resource]]
|
|
Linear Resource::
|
|
A resource is _linear_ if it is a slink:VkBuffer, or a slink:VkImage
|
|
created with ename:VK_IMAGE_TILING_LINEAR.
|
|
A resource is _non-linear_ if it is a slink:VkImage created with
|
|
ename:VK_IMAGE_TILING_OPTIMAL.
|
|
|
|
Local Workgroup::
|
|
A collection of compute shader invocations invoked by a single dispatch
|
|
command, which share data via code:WorkgroupLocal variables and can
|
|
synchronize with each other.
|
|
|
|
Logical Device::
|
|
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 slink:VkDevice object.
|
|
|
|
Logical Operation::
|
|
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.
|
|
|
|
Lost Device::
|
|
A state that a logical device may: be in as a result of unrecoverable
|
|
implementation errors, or other exceptional conditions.
|
|
|
|
Mappable::
|
|
See Host-Visible Memory.
|
|
|
|
Memory Dependency::
|
|
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
|
|
|
|
Memory Domain::
|
|
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).
|
|
|
|
Memory Domain Operation::
|
|
An operation that makes the writes that are available to one memory
|
|
domain available to another memory domain.
|
|
|
|
Memory Heap::
|
|
A region of memory from which device memory allocations can: be made.
|
|
|
|
Memory Type::
|
|
An index used to select a set of memory properties (e.g. mappable,
|
|
cached) for a device memory allocation.
|
|
|
|
Mip Tail Region::
|
|
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.
|
|
|
|
ifdef::VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion[]
|
|
Multi-planar::
|
|
A _multi-planar format_ (or "`planar format`") is an image format
|
|
consisting of more than one _plane_, identifiable with a etext:_2PLANE
|
|
or etext:_3PLANE component to the format name and listed in
|
|
<<features-formats-requiring-sampler-ycbcr-conversion>>.
|
|
A _multi-planar image_ (or "`planar image`") is an image of a
|
|
multi-planar format.
|
|
endif::VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion[]
|
|
|
|
Non-Dispatchable Handle::
|
|
A handle of an integer handle type.
|
|
Handle values may: not be unique, even for two objects of the same type.
|
|
|
|
Non-Indexed Drawing Commands::
|
|
_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 flink:vkCmdDraw,
|
|
ifdef::VK_KHR_draw_indirect_count[]
|
|
flink:vkCmdDrawIndirectCountKHR,
|
|
endif::VK_KHR_draw_indirect_count[]
|
|
ifdef::VK_AMD_draw_indirect_count[]
|
|
flink:vkCmdDrawIndirectCountAMD,
|
|
endif::VK_AMD_draw_indirect_count[]
|
|
and flink:vkCmdDrawIndirect.
|
|
|
|
Normalized::
|
|
A value that is interpreted as being in the range [eq]#[0,1]# as a
|
|
result of being implicitly divided by some other value.
|
|
|
|
Normalized Device Coordinates::
|
|
A coordinate space after perspective division is applied to clip
|
|
coordinates, and before the viewport transformation converts to
|
|
framebuffer coordinates.
|
|
|
|
ifdef::VK_NVX_device_generated_commands[]
|
|
Object Table::
|
|
A binding table for various resources (slink:VkPipeline, slink:VkBuffer,
|
|
slink:VkDescriptorSet), so that they can be referenced in
|
|
device-generated command processing.
|
|
Represented as slink:VkObjectTableNVX.
|
|
Entries are registered or unregistered via code:uint32_t indices.
|
|
endif::VK_NVX_device_generated_commands[]
|
|
|
|
Obsoleted::
|
|
A feature is obsolete if it can no longer be used.
|
|
For core features, making one obsolete would be in violation of the
|
|
<<fundamentals-versionnum, compatibility rules>>, so must not be done.
|
|
However extensions do not have these guarantees, and can be made
|
|
obsolete by a newer core version or extension.
|
|
|
|
Overlapped Range (Aliased Range)::
|
|
The aliased range of a device memory allocation that intersects a given
|
|
image subresource of an image or range of a buffer.
|
|
|
|
Ownership (Resource)::
|
|
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.
|
|
|
|
Packed Format::
|
|
A format whose components are stored as a single data element in memory,
|
|
with their relative locations defined within that element.
|
|
|
|
ifdef::VK_NV_geometry_shader_passthrough[]
|
|
Passthrough Geometry Shader::
|
|
A geometry shader which uses the code: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.
|
|
endif::VK_NV_geometry_shader_passthrough[]
|
|
|
|
ifdef::VK_VERSION_1_1,VK_KHR_external_semaphore,VK_KHR_external_fence[]
|
|
Payload::
|
|
Importable or exportable reference to the internal data of an object in
|
|
Vulkan.
|
|
endif::VK_VERSION_1_1,VK_KHR_external_semaphore,VK_KHR_external_fence[]
|
|
|
|
ifdef::VK_VERSION_1_1,VK_KHR_device_group[]
|
|
Peer Memory::
|
|
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.
|
|
endif::VK_VERSION_1_1,VK_KHR_device_group[]
|
|
|
|
Physical Device::
|
|
An object that represents a single device in the system.
|
|
Represented by a slink:VkPhysicalDevice object.
|
|
|
|
Physical-Device-Level Command::
|
|
Any command that is dispatched from a physical device.
|
|
|
|
Physical-Device-Level Functionality::
|
|
All physical-device-level commands and objects, and their structures,
|
|
enumerated types, and enumerants.
|
|
|
|
Physical-Device-Level Object::
|
|
Physical device objects.
|
|
For example, slink:VkPhysicalDevice is a physical-device-level object.
|
|
|
|
Pipeline::
|
|
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 slink:VkPipeline object.
|
|
|
|
Pipeline Barrier::
|
|
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.
|
|
|
|
Pipeline Cache::
|
|
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 slink:VkPipelineCache object.
|
|
|
|
Pipeline Layout::
|
|
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 slink:VkPipelineLayout object.
|
|
|
|
Pipeline Stage::
|
|
A logically independent execution unit that performs some of the
|
|
operations defined by an action command.
|
|
|
|
pname:pNext Chain::
|
|
A set of structures <<fundamentals-validusage-pNext,chained together>>
|
|
through their ptext:pNext members.
|
|
|
|
ifdef::VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion[]
|
|
Planar::
|
|
See _multi-planar_.
|
|
|
|
Plane::
|
|
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 flink:vkGetImageSubresourceLayout.
|
|
If a multi-planar image is created with the
|
|
ename:VK_IMAGE_CREATE_DISJOINT_BIT bit set, the image is described as
|
|
_disjoint_, and its planes are therefore are bound to memory
|
|
independently.
|
|
endif::VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion[]
|
|
|
|
Point Sampling (Rasterization)::
|
|
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.
|
|
|
|
ifdef::VK_KHR_swapchain[]
|
|
Presentable image::
|
|
A sname:VkImage object obtained from a sname:VkSwapchainKHR used to
|
|
present to a sname:VkSurfaceKHR object.
|
|
endif::VK_KHR_swapchain[]
|
|
|
|
Preserve Attachment::
|
|
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.
|
|
|
|
Primary Command Buffer::
|
|
A command buffer that can: execute secondary command buffers, and can:
|
|
be submitted directly to a queue.
|
|
|
|
Primitive Topology::
|
|
State that controls how vertices are assembled into primitives, e.g. as
|
|
lists of triangles, strips of lines, etc..
|
|
|
|
Promoted::
|
|
A feature is promoted if it is taken from an older extension and made
|
|
available as part of a new <<versions,core version of the API>>, or a
|
|
newer extension that is considered to be either as widely supported or
|
|
more so.
|
|
A promoted feature may have minor differences from the original such as:
|
|
* It may be renamed
|
|
* A small number of non-intrusive parameters may have been added
|
|
* The feature may be advertised differently by
|
|
<<features-features,device features>>
|
|
* The author ID suffixes will be changed or removed as appropriate
|
|
|
|
ifdef::VK_VERSION_1_1[]
|
|
Protected Buffer::
|
|
A buffer to which protected device memory can: be bound.
|
|
|
|
Protected-capable Device Queue::
|
|
A device queue to which protected command buffers can: be submitted.
|
|
|
|
Protected Command Buffer::
|
|
A command buffer which can: be submitted to a protected-capable device
|
|
queue.
|
|
|
|
Protected Device Memory::
|
|
Device memory which can: be visible to the device but must: not be
|
|
visible to the host.
|
|
|
|
Protected Image::
|
|
An image to which protected device memory can: be bound.
|
|
endif::VK_VERSION_1_1[]
|
|
|
|
Provisional::
|
|
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.
|
|
|
|
Provoking Vertex::
|
|
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.
|
|
|
|
Push Constants::
|
|
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.
|
|
|
|
Push Constant Interface::
|
|
The set of variables with code:PushConstant storage class that are
|
|
statically used by a shader entry point, and which receive values from
|
|
push constant commands.
|
|
|
|
ifdef::VK_KHR_push_descriptor[]
|
|
Push Descriptors::
|
|
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.
|
|
endif::VK_KHR_push_descriptor[]
|
|
|
|
ifdef::VK_VERSION_1_1,VK_KHR_descriptor_update_template[]
|
|
Descriptor Update Template::
|
|
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.
|
|
|
|
endif::VK_VERSION_1_1,VK_KHR_descriptor_update_template[]
|
|
|
|
Query Pool::
|
|
An object that contains a number of query entries and their associated
|
|
state and results.
|
|
Represented by a slink:VkQueryPool object.
|
|
|
|
Queue::
|
|
An object that executes command buffers and sparse binding operations on
|
|
a device.
|
|
Represented by a slink:VkQueue object.
|
|
|
|
Queue Family::
|
|
A set of queues that have common properties and support the same
|
|
functionality, as advertised in slink:VkQueueFamilyProperties.
|
|
|
|
Queue Operation::
|
|
A unit of work to be executed by a specific queue on a device, submitted
|
|
via a <<devsandqueues-submission, 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.
|
|
|
|
Queue Submission::
|
|
Zero or more batches and an optional fence to be signaled, passed to a
|
|
command for execution on a queue.
|
|
See the <<devsandqueues-submission, Devices and Queues chapter>> for
|
|
more information.
|
|
|
|
Recording State (Command Buffer)::
|
|
A command buffer that is ready to record commands.
|
|
See also Initial State and Executable State.
|
|
|
|
Release Operation (Resource)::
|
|
An operation that releases ownership of an image subresource or buffer
|
|
range.
|
|
|
|
Render Pass::
|
|
An object that represents a set of framebuffer attachments and phases of
|
|
rendering using those attachments.
|
|
Represented by a slink:VkRenderPass object.
|
|
|
|
Render Pass Instance::
|
|
A use of a render pass in a command buffer.
|
|
|
|
Required Extensions::
|
|
Extensions that must: be enabled alongside extensions dependent on them
|
|
(see <<extended-functionality-extensions-dependencies, Extension
|
|
Dependencies>>).
|
|
|
|
Reset (Command Buffer)::
|
|
Resetting a command buffer discards any previously recorded commands and
|
|
puts a command buffer in the initial state.
|
|
|
|
Residency Code::
|
|
An integer value returned by sparse image instructions, indicating
|
|
whether any sparse unbound texels were accessed.
|
|
|
|
Resolve Attachment::
|
|
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.
|
|
|
|
ifdef::VK_KHR_swapchain[]
|
|
Retired Swapchain::
|
|
A swapchain that has been used as the pname:oldSwapchain parameter to
|
|
flink: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.
|
|
endif::VK_KHR_swapchain[]
|
|
|
|
Sampled Image::
|
|
A descriptor type that represents an image view, and supports filtered
|
|
(sampled) and unfiltered read-only access in a shader.
|
|
|
|
Sampler::
|
|
An object that contains 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 slink:VkSampler object.
|
|
|
|
Secondary Command Buffer::
|
|
A command buffer that can: be executed by a primary command buffer, and
|
|
must: not be submitted directly to a queue.
|
|
|
|
Self-Dependency::
|
|
A subpass dependency from a subpass to itself, i.e. with
|
|
pname:srcSubpass equal to pname:dstSubpass.
|
|
A self-dependency is not automatically performed during a render pass
|
|
instance, rather a subset of it can: be performed via
|
|
flink:vkCmdPipelineBarrier during the subpass.
|
|
|
|
Semaphore::
|
|
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 slink:VkSemaphore object.
|
|
|
|
Shader::
|
|
Instructions selected (via an entry point) from a shader module, which
|
|
are executed in a shader stage.
|
|
|
|
Shader Code::
|
|
A stream of instructions used to describe the operation of a shader.
|
|
|
|
Shader Module::
|
|
A collection of shader code, potentially including several functions and
|
|
entry points, that is used to create shaders in pipelines.
|
|
Represented by a slink:VkShaderModule object.
|
|
|
|
Shader Stage::
|
|
A stage of the graphics or compute pipeline that executes shader code.
|
|
|
|
ifdef::VK_KHR_shared_presentable_image[]
|
|
Shared presentable image::
|
|
A presentable image created from a swapchain with elink:VkPresentModeKHR
|
|
set to either ename:VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR or
|
|
ename:VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR.
|
|
endif::VK_KHR_shared_presentable_image[]
|
|
|
|
Side Effect::
|
|
A store to memory or atomic operation on memory from a shader
|
|
invocation.
|
|
|
|
ifdef::VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion[]
|
|
Single-plane format::
|
|
A format that is not _multi-planar_.
|
|
endif::VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion[]
|
|
|
|
Size-Compatible Image Formats::
|
|
When a compressed image format and an uncompressed image format are
|
|
size-compatible, it means that the element size of the uncompressed
|
|
format must: equal the element size (compressed texel block size) of the
|
|
compressed format.
|
|
|
|
Sparse Block::
|
|
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.
|
|
|
|
Sparse Image Block::
|
|
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.
|
|
|
|
Sparse Unbound Texel::
|
|
A texel read from a region of a sparse texture that does not have memory
|
|
bound to it.
|
|
|
|
Static Use::
|
|
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.
|
|
|
|
Storage Buffer::
|
|
A descriptor type that represents a buffer, and supports reads, writes,
|
|
and atomics in a shader.
|
|
|
|
Storage Image::
|
|
A descriptor type that represents an image view, and supports unfiltered
|
|
loads, stores, and atomics in a shader.
|
|
|
|
Storage Texel Buffer::
|
|
A descriptor type that represents a buffer view, and supports
|
|
unfiltered, formatted reads, writes, and atomics in a shader.
|
|
|
|
ifdef::VK_EXT_shader_subgroup_vote,VK_VERSION_1_1[]
|
|
Subgroup::
|
|
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.
|
|
endif::VK_EXT_shader_subgroup_vote,VK_VERSION_1_1[]
|
|
|
|
ifdef::VK_EXT_shader_subgroup_ballot,VK_VERSION_1_1[]
|
|
Subgroup Mask::
|
|
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 code:SubgroupSize) in
|
|
the last required vector component.
|
|
endif::VK_EXT_shader_subgroup_ballot,VK_VERSION_1_1[]
|
|
|
|
Subpass::
|
|
A phase of rendering within a render pass, that reads and writes a
|
|
subset of the attachments.
|
|
|
|
Subpass Dependency::
|
|
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.
|
|
|
|
Subpass Description::
|
|
Lists of attachment indices for input attachments, color attachments,
|
|
depth/stencil attachment, resolve attachments, and preserve attachments
|
|
used by the subpass in a render pass.
|
|
|
|
Subset (Self-Dependency)::
|
|
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.
|
|
|
|
Texel Coordinate System::
|
|
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.
|
|
|
|
Uniform Texel Buffer::
|
|
A descriptor type that represents a buffer view, and supports
|
|
unfiltered, formatted, read-only access in a shader.
|
|
|
|
Uniform Buffer::
|
|
A descriptor type that represents a buffer, and supports read-only
|
|
access in a shader.
|
|
|
|
Units in the Last Place (ULP)::
|
|
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 <<spirvenv-precision-operation, 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".
|
|
|
|
Unnormalized::
|
|
A value that is interpreted according to its conventional
|
|
interpretation, and is not normalized.
|
|
|
|
ifdef::VK_VERSION_1_1[]
|
|
Unprotected Buffer::
|
|
A buffer to which unprotected device memory can: be bound.
|
|
|
|
Unprotected Command Buffer::
|
|
A command buffer which can: be submitted to an unprotected device queue
|
|
or a protected-capable device queue.
|
|
|
|
Unprotected Device Memory::
|
|
Device memory which can: be visible to the device and can: be visible to
|
|
the host.
|
|
|
|
Unprotected Image::
|
|
An image to which unprotected device memory can: be bound.
|
|
endif::VK_VERSION_1_1[]
|
|
|
|
User-Defined Variable Interface::
|
|
A shader entry point's variables with code:Input or code:Output storage
|
|
class that are not built-in variables.
|
|
|
|
Vertex Input Attribute::
|
|
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.
|
|
|
|
ifdef::VK_EXT_validation_cache[]
|
|
Validation Cache::
|
|
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 slink:VkValidationCacheEXT object.
|
|
endif::VK_EXT_validation_cache[]
|
|
|
|
Vertex Input Binding::
|
|
A graphics pipeline resource that is bound to a buffer and includes
|
|
state that affects addressing calculations within that buffer.
|
|
|
|
Vertex Input Interface::
|
|
A vertex shader entry point's variables with code:Input storage class,
|
|
which receive values from vertex input attributes.
|
|
|
|
Vertex Processing Stages::
|
|
A set of shader stages that comprises the vertex shader, tessellation
|
|
control shader, tessellation evaluation shader, and geometry shader
|
|
stages.
|
|
|
|
ifdef::VK_VERSION_1_1,VK_KHR_multiview[]
|
|
View Mask::
|
|
When multiview is enabled, a view mask is a property of a subpass
|
|
controlling which views the rendering commands are broadcast to.
|
|
endif::VK_VERSION_1_1,VK_KHR_multiview[]
|
|
|
|
View Volume::
|
|
A subspace in homogeneous coordinates, corresponding to post-projection
|
|
x and y values between -1 and +1, and z values between 0 and +1.
|
|
|
|
Viewport Transformation::
|
|
A transformation from normalized device coordinates to framebuffer
|
|
coordinates, based on a viewport rectangle and depth range.
|
|
|
|
Visibility Operation::
|
|
An operation that causes available values to become visible to specified
|
|
memory accesses.
|
|
|
|
Visible::
|
|
A state of values written to memory that allows them to be accessed by a
|
|
set of operations.
|
|
|
|
// To be added per issue 18:
|
|
// Current State <<fundamentals-queueoperation>>
|
|
// Barycentric Coordinates <<primsrast-polygons-basic>>
|
|
// Internal Allocations <<memory-host-allocation-scope>>
|
|
// Unavailable, Available <<queries-operation>> - NB: this clashes with available/visible in terms of memory
|
|
// Signaled, Unsignaled <<synchronization-semaphores>> <<synchronization-fences>>
|
|
// Interior Vertices <<tessellation-tessellator-spacing>>
|
|
// Inner Vertices <<tessellation-triangle-tessellation>> <<tessellation-quad-tessellation>>
|
|
// Isolines <<tessellation-isoline-tessellation>>
|
|
// Binding Range <<sparsemem-memory-binding>>
|
|
|
|
|
|
[glossary]
|
|
= Common Abbreviations
|
|
|
|
Abbreviations and acronyms are sometimes used in the Specification and the
|
|
API where they are considered clear and commonplace, and are defined here:
|
|
|
|
Src::
|
|
Source
|
|
|
|
Dst::
|
|
Destination
|
|
|
|
Min::
|
|
Minimum
|
|
|
|
Max::
|
|
Maximum
|
|
|
|
Rect::
|
|
Rectangle
|
|
|
|
Info::
|
|
Information
|
|
|
|
LOD::
|
|
Level of Detail
|
|
|
|
ID::
|
|
Identifier
|
|
|
|
UUID::
|
|
Universally Unique Identifier
|
|
|
|
Op::
|
|
Operation
|
|
|
|
R::
|
|
Red color component
|
|
|
|
G::
|
|
Green color component
|
|
|
|
B::
|
|
Blue color component
|
|
|
|
A::
|
|
Alpha color component
|
|
|
|
|
|
[glossary]
|
|
= Prefixes
|
|
|
|
Prefixes are used in the API to denote specific semantic meaning of Vulkan
|
|
names, or as a label to avoid name clashes, and are explained here:
|
|
|
|
VK/Vk/vk::
|
|
Vulkan namespace +
|
|
All types, commands, enumerants and defines in this specification are
|
|
prefixed with these two characters.
|
|
|
|
PFN/pfn::
|
|
Function Pointer +
|
|
Denotes that a type is a function pointer, or that a variable is of a
|
|
pointer type.
|
|
|
|
p::
|
|
Pointer +
|
|
Variable is a pointer.
|
|
|
|
vkCmd::
|
|
Commands that record commands in command buffers +
|
|
These API commands do not result in immediate processing on the device.
|
|
Instead, they record the requested action in a command buffer for
|
|
execution when the command buffer is submitted to a queue.
|
|
|
|
s::
|
|
Structure +
|
|
Used to denote the etext:VK_STRUCTURE_TYPE* member of each structure in
|
|
pname:sType
|