Vulkan-Docs/doc/specs/vulkan/appendices/glossary.txt

// Copyright (c) 2015-2016 The Khronos Group Inc.
// Copyright notice at https://www.khronos.org/registry/speccopyright.html

// The asciidoc [glossary] template cannot contain subsections.
// The abbreviations and prefixes probably belong in the upcoming
// API/extension-writing-guidelines appendix, anyway.

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

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.

API Order::
    A set of ordering rules that govern how primitives in draw commands
    affect the framebuffer.

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 sname: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 sname: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.

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 sname: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 sname: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.

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.

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.

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 sname:VkImage (or sname: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 sname: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 sname: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 sname:VkDescriptorSetLayout object.

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

Device Memory::
    Memory accessible to the device.
    Represented by a sname:VkDeviceMemory object.

Device-Level Object::
    Logical device objects and their child objects For example,
    sname:VkDevice, sname:VkQueue, and sname: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.

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, 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 sname: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.

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

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.

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 sname: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::
    A fragment shader entry point's variables with code:UniformConstant
    storage class and a decoration of code:InputAttachmentIndex, which
    receive values from input attachments.

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 sname: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.

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.

Image::
    A resource that represents a multi-dimensional formatted interpretation
    of device memory.
    Represented by a sname: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 sname: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.

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.

Indirect Commands::
    Drawing or dispatching commands that source some of their parameters
    from structures in buffer memory.
    Includes flink:vkCmdDrawIndirect, flink:vkCmdDrawIndexedIndirect, 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
    sname:VkIndirectCommandsTokenTypeNVX, which represent asubset of
    traditional command buffer commands.
    Represented as sname:VkIndirectCommandsLayoutNVX.
endif::VK_NVX_device_generated_commands[]

Initial State (Command Buffer)::
    A command buffer that has not begun recording commands.
    See also Recorded State and Executable State.

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 sname:VkInstance object.

Instance-Level Object::
    High-level Vulkan objects, which are not logical devices, nor children
    of logical devices.
    For example, sname:VkInstance and sname:VkPhysicalDevice objects are
    instance-level objects.

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.

Local Workgroup::
    A collection of compute shader invocations invoked by a single dispatch
    command, which share shared memory 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 sname: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 hardware 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 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.

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

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 (sname:VkPipeline, sname:VkBuffer,
    sname:VkDescriptorSet), so that they can be referenced in
    device-generated command processing.
    Represented as sname:VkObjectTableNVX.
    Entries are registered or unregistered via ftext:uint32_t indices.
endif::VK_NVX_device_generated_commands[]

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.

Physical Device::
    An object that represents a single device in the system.
    Represented by a sname:VkPhysicalDevice 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 sname: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 sname: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 sname:VkPipelineLayout object.

Pipeline Stage::
    A logically independent execution unit that performs some of the
    operations defined by an action command.
    
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.

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

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.

Query Pool::
    An object that contains a number of query entries and their associated
    state and results.
    Represented by a sname:VkQueryPool object.

Queue::
    An object that executes command buffers and sparse binding operations on
    a device.
    Represented by a sname: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 sname:VkRenderPass object.

Render Pass Instance::
    A use of a render pass in a command buffer.

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.

Sampled Image::
    A descriptor type that represents an image view, and supports filtered
    (sampled) and unfiltered read-only acccess 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 sname: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 sname: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 sname:VkShaderModule object.

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

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

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.

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.

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

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.

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.

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