| // Copyright 2015-2023 The Khronos Group Inc. |
| // |
| // SPDX-License-Identifier: CC-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. |
| |
| [appendix] |
| [[lexicon]] |
| = Lexicon |
| |
| This appendix defines terms, abbreviations, and API prefixes used in the |
| Specification. |
| |
| |
| [[glossary]] |
| == Glossary |
| |
| The terms defined in this section are used consistently throughout the |
| 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. |
| |
| ifdef::VK_EXT_mutable_descriptor_type,VK_VALVE_mutable_descriptor_type[] |
| Active (Descriptor Type):: |
| When a descriptor with _mutable_ type is updated with |
| flink:vkUpdateDescriptorSets, the active descriptor type changes. |
| When the descriptor is consumed by shaders, it is the active descriptor |
| type which determines validity, i.e. |
| sname:VkDescriptorSetLayoutBinding::pname:descriptorType is replaced |
| with the active descriptor type. |
| A mismatch in active descriptor type and consumption by shader is |
| considered an undefined: descriptor. |
| endif::VK_EXT_mutable_descriptor_type,VK_VALVE_mutable_descriptor_type[] |
| |
| ifdef::VK_EXT_transform_feedback[] |
| Active (Transform Feedback):: |
| Transform feedback is made active after |
| flink:vkCmdBeginTransformFeedbackEXT executes and remains active until |
| flink:vkCmdEndTransformFeedbackEXT executes. |
| While transform feedback is active, data written to variables in the |
| output interface of the last |
| <<pipelines-graphics-subsets-pre-rasterization,pre-rasterization shader |
| stage>> of the graphics pipeline are captured to the bound transform |
| feedback buffers if those variables are decorated for transform |
| feedback. |
| endif::VK_EXT_transform_feedback[] |
| |
| 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_NV_ray_tracing,VK_KHR_acceleration_structure[] |
| Active Object (Ray Tracing):: |
| A primitive or instance in a ray tracing acceleration structure which |
| has a corresponding ID, and is not _inactive_ (meaning that it is |
| visible to rays). |
| endif::VK_NV_ray_tracing,VK_KHR_acceleration_structure[] |
| |
| ifdef::VK_EXT_blend_operation_advanced[] |
| Advanced Blend Operation:: |
| Blending performed using one of the blend operation enums introduced by |
| the `apiext:VK_EXT_blend_operation_advanced` extension. |
| See <<framebuffer-blend-advanced, Advanced Blending Operations>>. |
| endif::VK_EXT_blend_operation_advanced[] |
| |
| Alias (API type/command):: |
| An identical definition of another API type/command with the same |
| behavior but a different name. |
| |
| 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):: |
| Some image types contain multiple kinds (called "`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 can: be used as a framebuffer color attachment. |
| Some operations, like depth testing, operate only on specific aspects of |
| an image. |
| |
| 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. |
| |
| ifdef::VK_NV_ray_tracing,VK_KHR_acceleration_structure[] |
| Axis-aligned Bounding Box:: |
| A box bounding a region in space defined by extents along each axis and |
| thus representing a box where each edge is aligned to one of the major |
| axes. |
| endif::VK_NV_ray_tracing,VK_KHR_acceleration_structure[] |
| |
| 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. |
| |
| Binary Semaphore:: |
| A semaphore with a boolean payload indicating whether the semaphore is |
| signaled or unsignaled. |
| Represented by a slink:VkSemaphore object |
| ifdef::VK_VERSION_1_2,VK_KHR_timeline_semaphore[] |
| created with a semaphore type of ename:VK_SEMAPHORE_TYPE_BINARY |
| endif::VK_VERSION_1_2,VK_KHR_timeline_semaphore[] |
| . |
| |
| 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, |
| ifdef::VKSC_VERSION_1_0[and] |
| using the flink:vkBindImageMemory command for non-sparse image objects |
| ifndef::VKSC_VERSION_1_0[, 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. |
| |
| ifdef::VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address[] |
| Buffer Device Address:: |
| A 64-bit value used in a shader to access buffer memory through the |
| code:PhysicalStorageBuffer storage class. |
| endif::VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address[] |
| |
| Buffer View:: |
| An object that represents a range of a specific buffer, and state |
| controlling 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 containing only variables decorated with |
| built-in decorations, and is used to match against other shader stages. |
| |
| Clip Coordinates:: |
| The homogeneous coordinate space in which vertex positions |
| (code:Position decoration) are written by |
| <<pipelines-graphics-subsets-pre-rasterization, pre-rasterization shader |
| stages>>. |
| |
| Clip Distance:: |
| A built-in output from |
| <<pipelines-graphics-subsets-pre-rasterization,pre-rasterization shader |
| stages>> defining 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 one of the following, depending on the image's tiling: |
| * slink:VkFormatProperties::pname:linearTilingFeatures |
| * slink:VkFormatProperties::pname:optimalTilingFeatures |
| ifdef::VK_NV_linear_color_attachment[] |
| or a elink:VkFormat where |
| ename:VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV is set in |
| slink:VkFormatProperties::pname:linearTilingFeatures |
| endif::VK_NV_linear_color_attachment[] |
| ifdef::VK_EXT_image_drm_format_modifier[] |
| * slink:VkDrmFormatModifierPropertiesEXT::pname:drmFormatModifierTilingFeatures |
| endif::VK_EXT_image_drm_format_modifier[] |
| |
| 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. |
| |
| ifdef::VK_EXT_nested_command_buffer[] |
| Command Buffer Nesting Level:: |
| The Command Buffer Nesting Level of a secondary command buffer is equal |
| to the maximum nesting level of all secondary command buffers executed |
| by that command buffer plus one, where a secondary command buffer that |
| executes no other secondary command buffers has a nesting level of zero. |
| endif::VK_EXT_nested_command_buffer[] |
| |
| 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. |
| |
| Complete Mipmap Chain:: |
| The entire set of mip levels that can be provided for an image, from the |
| largest application specified mip level size down to the _minimum mip |
| level size_. |
| See <<resources-image-mip-level-sizing, Image Mip Level Sizing>>. |
| |
| ifdef::VK_KHR_deferred_host_operations[] |
| Completed Operation:: |
| A deferred operation whose corresponding command has been executed to |
| completion. |
| See <<deferred-host-operations, Deferred Host Operations>> |
| endif::VK_KHR_deferred_host_operations[] |
| |
| Component (Format):: |
| A distinct part of a format. |
| Color components are represented with `R`, `G`, `B`, and `A`. |
| Depth and stencil components are represented with `D` and `S`. |
| Formats can: have multiple instances of the same component. |
| Some formats have other notations such as `E` or `X` which are not |
| considered a component of the format. |
| |
| 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 defining the dimensions of these |
| elements in units of texels, and a size in bytes of the encoding in |
| memory. |
| |
| Constant Integral Expressions:: |
| A SPIR-V constant instruction whose type is code:OpTypeInt. |
| See _Constant Instruction_ in section 2.2.1 "`Instructions`" of the |
| <<spirv-spec,Khronos SPIR-V Specification>>. |
| |
| ifdef::VK_NV_cooperative_matrix,VK_KHR_cooperative_matrix[] |
| Cooperative Matrix:: |
| A SPIR-V type where the storage for and computations performed on the |
| matrix are spread across a set of invocations such as a subgroup. |
| endif::VK_NV_cooperative_matrix,VK_KHR_cooperative_matrix[] |
| |
| ifdef::VK_NV_corner_sampled_image[] |
| Corner-Sampled Image:: |
| A slink:VkImage where unnormalized texel coordinates are centered on |
| integer values instead of half-integer values. |
| Specified by setting the ename:VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV bit |
| on slink:VkImageCreateInfo::pname:flags at image creation. |
| endif::VK_NV_corner_sampled_image[] |
| |
| Coverage Index:: |
| The index of a sample in the coverage mask. |
| |
| Coverage Mask:: |
| A bitfield associated with a fragment representing the samples that were |
| determined to be covered based on the result of rasterization, and then |
| subsequently modified by fragment operations or the fragment shader. |
| |
| Cull Distance:: |
| A built-in output from |
| <<pipelines-graphics-subsets-pre-rasterization,pre-rasterization shader |
| stages>> defining 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. |
| |
| ifdef::VK_KHR_video_queue[] |
| Decode Output Picture:: |
| A video picture resource used to store the result of a video decode |
| operation. |
| |
| Decoded Picture Buffer:: |
| An indexed set of reference pictures used by a video session. |
| Abbreviated as DPB. |
| |
| Decoded Picture Buffer Slot:: |
| An entry within a DPB that can: be associated with a particular |
| reference picture. |
| |
| Decoded Picture Buffer Slot Index:: |
| The index of a DPB slot within its encompassing DPB. |
| endif::VK_KHR_video_queue[] |
| |
| 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. |
| |
| ifdef::VK_KHR_deferred_host_operations[] |
| Deferrable Command:: |
| A command which allows deferred execution of host-side work. |
| See <<deferred-host-operations,Deferred Host Operations>>. |
| |
| Deferrable Operation:: |
| A single logical item of host-side work which can be deferred. |
| Represented by the slink:VkDeferredOperationKHR object. |
| See <<deferred-host-operations,Deferred Host Operations>>. |
| endif::VK_KHR_deferred_host_operations[] |
| |
| Deprecated (feature):: |
| A feature is deprecated if it is no longer recommended as the correct or |
| best way to achieve its intended purpose. |
| |
| 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. |
| |
| ifdef::VK_VERSION_1_2,VK_KHR_depth_stencil_resolve[] |
| Depth/Stencil Resolve Attachment:: |
| A subpass attachment point, or image view, that is the target of a |
| multisample resolve operation from the corresponding depth/stencil |
| attachment at the end of the subpass. |
| endif::VK_VERSION_1_2,VK_KHR_depth_stencil_resolve[] |
| |
| Derivative Group:: |
| A set of fragment |
| ifdef::VK_NV_compute_shader_derivatives[] |
| or compute |
| endif::VK_NV_compute_shader_derivatives[] |
| 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 defining 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. |
| Additionally, physical-device-level functionality defined by a |
| <<extendingvulkan-device-extensions,device extension>> is also |
| considered device-level functionality. |
| |
| 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 |
| ifdef::VK_EXT_multi_draw[] |
| flink:vkCmdDrawMultiIndexedEXT, flink:vkCmdDrawMultiEXT, |
| endif::VK_EXT_multi_draw[] |
| ifdef::VK_NV_mesh_shader[] |
| flink:vkCmdDrawMeshTasksNV, |
| endif::VK_NV_mesh_shader[] |
| ifdef::VK_EXT_mesh_shader[] |
| flink:vkCmdDrawMeshTasksEXT, |
| endif::VK_EXT_mesh_shader[] |
| 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 Command:: |
| A non-global command. |
| The first argument to each dispatchable command is a dispatchable handle |
| type. |
| |
| Dispatchable Handle:: |
| A handle of a pointer handle type which may: be used by layers as part |
| of intercepting API commands. |
| |
| 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, |
| ifdef::VK_VERSION_1_2[] |
| flink:vkCmdDrawIndirectCount, flink:vkCmdDrawIndexedIndirectCount, |
| endif::VK_VERSION_1_2[] |
| 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[] |
| ifdef::VK_EXT_multi_draw[] |
| flink:vkCmdDrawMultiIndexedEXT, flink:vkCmdDrawMultiEXT, |
| endif::VK_EXT_multi_draw[] |
| ifdef::VK_NV_mesh_shader[] |
| flink:vkCmdDrawMeshTasksNV, flink:vkCmdDrawMeshTasksIndirectNV, |
| flink:vkCmdDrawMeshTasksIndirectCountNV, |
| endif::VK_NV_mesh_shader[] |
| ifdef::VK_EXT_mesh_shader[] |
| flink:vkCmdDrawMeshTasksEXT, flink:vkCmdDrawMeshTasksIndirectEXT, |
| flink:vkCmdDrawMeshTasksIndirectCountEXT, |
| endif::VK_EXT_mesh_shader[] |
| 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>>. |
| |
| ifdef::VK_KHR_video_queue[] |
| Encode Input Picture:: |
| A video picture resource used as the input of a video encode operation. |
| endif::VK_KHR_video_queue[] |
| |
| Element:: |
| Arrays are composed of multiple elements, where each element exists at a |
| unique index within that array. |
| Used primarily to describe data passed to or returned from the Vulkan |
| API. |
| |
| 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 completes 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 {YCbCr} 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. |
| |
| Extending Structure:: |
| A structure type which may appear in the _pname:pNext chain_ of another |
| structure, extending the functionality of the other structure. |
| Extending structures may be defined by either core API versions or |
| extensions. |
| |
| 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. |
| |
| ifdef::VK_KHR_video_coding[] |
| Field (Video):: |
| Possibly discontinuous subregions of a frame. |
| Frames may: consist of two fields, a top field and a bottom field. |
| endif::VK_KHR_video_coding[] |
| |
| 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. |
| |
| Format Features:: |
| A set of features from elink:VkFormatFeatureFlagBits that a |
| elink:VkFormat is capable of using for various commands. |
| The list is determined by factors such as elink:VkImageTiling. |
| |
| Fragment:: |
| A rectangular framebuffer region with associated data produced by |
| <<primsrast,rasterization>> and processed by <<fragops,fragment |
| operations>> including the fragment shader. |
| |
| [[glossary-fragment-area]] |
| Fragment Area:: |
| The width and height, in pixels, of a fragment. |
| |
| ifdef::VK_EXT_fragment_density_map[] |
| [[glossary-fragment-density]] |
| Fragment Density:: |
| The ratio of fragments per framebuffer area in the x and y direction. |
| |
| [[glossary-fragment-density-texel-size]] |
| Fragment Density Texel Size:: |
| The [eq]#(w,h)# framebuffer region in pixels that each texel in a |
| fragment density map applies to. |
| endif::VK_EXT_fragment_density_map[] |
| |
| 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. |
| |
| ifdef::VK_KHR_video_queue[] |
| Frame (Video):: |
| A multi-dimensional array of luma samples and an optional |
| multi-dimensional array of chroma samples. |
| endif::VK_KHR_video_queue[] |
| |
| ifdef::VK_EXT_shader_tile_image[] |
| [[glossary-fragment-tile-image-interface]] |
| Fragment Tile Image Interface:: |
| A fragment shader entry point's variables with code:TileImageEXT storage |
| class and a decoration of code:Location, which are used to read values |
| from color attachments. |
| endif::VK_EXT_shader_tile_image[] |
| |
| 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. |
| |
| 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. |
| |
| Global Command:: |
| A Vulkan command for which the first argument is not a dispatchable |
| handle type. |
| |
| Global Workgroup:: |
| A collection of local workgroups dispatched by a single dispatching |
| ifdef::VK_NV_mesh_shader,VK_EXT_mesh_shader[or single mesh task drawing] |
| 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, happens-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, happens-before:: |
| A transitive, irreflexive and antisymmetric ordering relation between |
| operations. |
| An execution dependency with a source of *A* and a destination of *B* |
| enforces that *A* happens-before *B*. |
| The inverse relation of happens-after. |
| |
| 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 Mapped Device Memory:: |
| Device memory that is mapped for host access using flink:vkMapMemory. |
| |
| 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. |
| |
| ICD:: |
| Installable Client Driver. |
| An ICD is represented as a slink:VkPhysicalDevice. |
| |
| [[glossary-identically-defined]] |
| 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, layer, and set of aspects 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 controlling how the contents are interpreted. |
| Represented by a slink:VkImageView object. |
| |
| Immutable Sampler:: |
| A sampler descriptor provided at descriptor set layout creation time for |
| a specific binding. |
| This sampler is then used for that binding in all descriptor sets |
| allocated with the layout, and it cannot: be changed. |
| |
| ifdef::VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion[] |
| Implicit chroma reconstruction:: |
| An implementation of sampler {YCbCr} 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. |
| |
| ifdef::VK_NV_ray_tracing,VK_KHR_acceleration_structure[] |
| Inactive Object (Ray Tracing):: |
| A primitive or instance in a ray tracing acceleration structure which |
| has a corresponding ID, but which will never report an intersection with |
| any ray. |
| endif::VK_NV_ray_tracing,VK_KHR_acceleration_structure[] |
| |
| 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_VERSION_1_2[] |
| flink:vkCmdDrawIndexedIndirectCount, |
| endif::VK_VERSION_1_2[] |
| 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[] |
| ifdef::VK_EXT_multi_draw[] |
| flink:vkCmdDrawMultiIndexedEXT, |
| endif::VK_EXT_multi_draw[] |
| 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_VERSION_1_2[] |
| flink:vkCmdDrawIndirectCount, flink:vkCmdDrawIndexedIndirectCount, |
| endif::VK_VERSION_1_2[] |
| 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[] |
| ifdef::VK_NV_mesh_shader[] |
| flink:vkCmdDrawMeshTasksIndirectNV, |
| flink:vkCmdDrawMeshTasksIndirectCountNV, |
| endif::VK_NV_mesh_shader[] |
| ifdef::VK_EXT_mesh_shader[] |
| flink:vkCmdDrawMeshTasksIndirectEXT, |
| flink:vkCmdDrawMeshTasksIndirectCountEXT, |
| endif::VK_EXT_mesh_shader[] |
| and flink:vkCmdDispatchIndirect. |
| |
| ifdef::VK_NV_device_generated_commands[] |
| Indirect Commands Layout:: |
| A definition of a sequence of commands, that are generated on the device |
| via flink:vkCmdPreprocessGeneratedCommandsNV and |
| flink:vkCmdExecuteGeneratedCommandsNV. |
| Each sequence is comprised of multiple |
| elink:VkIndirectCommandsTokenTypeNV, which represent a subset of |
| traditional command buffer commands. |
| Represented as slink:VkIndirectCommandsLayoutNV. |
| endif::VK_NV_device_generated_commands[] |
| |
| Indirect Drawing Commands:: |
| _Drawing commands_ that source some of their parameters from structures |
| in buffer memory. |
| Includes flink:vkCmdDrawIndirect, |
| ifdef::VK_VERSION_1_2[] |
| flink:vkCmdDrawIndirectCount, flink:vkCmdDrawIndexedIndirectCount, |
| endif::VK_VERSION_1_2[] |
| 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[] |
| ifdef::VK_NV_mesh_shader[] |
| flink:vkCmdDrawMeshTasksIndirectNV, |
| flink:vkCmdDrawMeshTasksIndirectCountNV, |
| endif::VK_NV_mesh_shader[] |
| ifdef::VK_EXT_mesh_shader[] |
| flink:vkCmdDrawMeshTasksIndirectEXT, |
| flink:vkCmdDrawMeshTasksIndirectCountEXT, |
| endif::VK_EXT_mesh_shader[] |
| and flink:vkCmdDrawIndexedIndirect. |
| |
| Initial State (Command Buffer):: |
| A command buffer that has not begun recording commands. |
| See also Recording State and Executable State. |
| |
| ifdef::VK_VERSION_1_3,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_VERSION_1_3,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. |
| |
| ifdef::VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing[] |
| Invocation Repack Instruction:: |
| A ray tracing shader call <<ray-tracing-repack,instruction>> where the |
| implementation may: change the set of invocations that are executing. |
| endif::VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing[] |
| |
| ifdef::VK_KHR_deferred_host_operations[] |
| Join (Deferred Host Operations):: |
| The act of instructing a thread to participate in the execution of a |
| deferred operation. |
| See <<deferred-host-operations, Deferred Host Operations>>. |
| endif::VK_KHR_deferred_host_operations[] |
| |
| ifdef::VK_NV_linear_color_attachment[] |
| [[glossary-linear-color-attachment]] |
| Linear Color Attachment:: |
| A color attachment with linear tiling |
| endif::VK_NV_linear_color_attachment[] |
| |
| [[glossary-linear-resource]] |
| Linear Resource:: |
| + |
| -- |
| A resource is _linear_ if it is one of the following: |
| |
| * a slink:VkBuffer |
| * a slink:VkImage created with ename:VK_IMAGE_TILING_LINEAR |
| ifdef::VK_EXT_image_drm_format_modifier[] |
| * a slink:VkImage created with |
| ename:VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT and whose |
| <<glossary-drm-format-modifier,Linux DRM format modifier>> is |
| code:DRM_FORMAT_MOD_LINEAR |
| endif::VK_EXT_image_drm_format_modifier[] |
| ifdef::VK_NV_ray_tracing[] |
| * a slink:VkAccelerationStructureNV |
| endif::VK_NV_ray_tracing[] |
| ifdef::VK_KHR_acceleration_structure[] |
| |
| Because a slink:VkAccelerationStructureKHR resource does not have memory |
| bound to it directly, it is considered neither linear nor non-linear. |
| However, the slink:VkBuffer on which a slink:VkAccelerationStructureKHR |
| resource is placed is a linear resource. |
| endif::VK_KHR_acceleration_structure[] |
| |
| A resource is _non-linear_ if it is one of the following: |
| |
| * a slink:VkImage created with ename:VK_IMAGE_TILING_OPTIMAL |
| ifdef::VK_EXT_image_drm_format_modifier[] |
| * a slink:VkImage created with |
| ename:VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT and whose |
| <<glossary-drm-format-modifier,Linux DRM format modifier>> is not |
| code:DRM_FORMAT_MOD_LINEAR |
| endif::VK_EXT_image_drm_format_modifier[] |
| -- |
| |
| ifdef::VK_EXT_image_drm_format_modifier[] |
| [[glossary-drm-format-modifier,Linux DRM format modifier]] |
| Linux DRM Format Modifier:: |
| A 64-bit, vendor-prefixed, semi-opaque unsigned integer describing |
| vendor-specific details of an image's memory layout. |
| In Linux graphics APIs, _modifiers_ are commonly used to specify the |
| memory layout of externally shared images. |
| An image has a _modifier_ if and only if it is created with pname:tiling |
| equal to ename:VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT. |
| For more details, refer to the appendix for extension |
| `apiext:VK_EXT_image_drm_format_modifier`. |
| endif::VK_EXT_image_drm_format_modifier[] |
| |
| Local Workgroup:: |
| A collection of compute shader invocations invoked by a single |
| dispatching 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. |
| |
| ifdef::VK_NV_mesh_shader,VK_EXT_mesh_shader[] |
| Mesh Shading Pipeline:: |
| A graphics pipeline where the primitives are assembled explicitly in the |
| shader stages. |
| In contrast to the primitive shading pipeline where input primitives are |
| assembled by fixed function processing. |
| |
| Mesh Tasks Drawing Commands:: |
| _Drawing commands_ which create shader invocations organized in |
| workgroups for drawing mesh tasks. |
| Includes |
| ifdef::VK_NV_mesh_shader[] |
| flink:vkCmdDrawMeshTasksNV, flink:vkCmdDrawMeshTasksIndirectNV, and |
| flink:vkCmdDrawMeshTasksIndirectCountNV, |
| endif::VK_NV_mesh_shader[] |
| ifdef::VK_EXT_mesh_shader[] |
| flink:vkCmdDrawMeshTasksEXT, flink:vkCmdDrawMeshTasksIndirectEXT, and |
| flink:vkCmdDrawMeshTasksIndirectCountEXT |
| endif::VK_EXT_mesh_shader[] |
| . |
| endif::VK_NV_mesh_shader,VK_EXT_mesh_shader[] |
| |
| Minimum Mip Level Size:: |
| The smallest size that is permitted for a mip level. |
| For conventional images this is 1x1x1. |
| ifdef::VK_NV_corner_sampled_image[] |
| For corner-sampled images, this is 2x2x2. |
| endif::VK_NV_corner_sampled_image[] |
| See <<resources-image-mip-level-sizing, Image Mip Level Sizing>>. |
| |
| 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 |
| <<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[] |
| |
| ifdef::VK_EXT_nested_command_buffer[] |
| Nested Command Buffers:: |
| A nested command buffer is a secondary command buffer that is executed |
| by another secondary command buffer, which may itself execute other |
| secondary command buffers. |
| endif::VK_EXT_nested_command_buffer[] |
| |
| 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_VERSION_1_2[] |
| flink:vkCmdDrawIndirectCount, |
| endif::VK_VERSION_1_2[] |
| 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[] |
| ifdef::VK_EXT_multi_draw[] |
| flink:vkCmdDrawMultiEXT, |
| endif::VK_EXT_multi_draw[] |
| 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 them to |
| framebuffer coordinates. |
| |
| Obsoleted (feature):: |
| A feature is obsolete if it can no longer be used. |
| |
| ifdef::VK_VERSION_1_2,VK_KHR_buffer_device_address[] |
| Opaque Capture Address:: |
| A 64-bit value representing the device address of a buffer or memory |
| object that is expected to be used by trace capture/replay tools in |
| combination with the <<features-bufferDeviceAddress, |
| pname:bufferDeviceAddress>> feature. |
| endif::VK_VERSION_1_2,VK_KHR_buffer_device_address[] |
| |
| 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 texel block 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_NV_mesh_shader[] |
| Per-View:: |
| A variable that has an array of values which are output, one for each |
| view that is being generated. |
| A mesh shader which uses the code:PerViewNV decoration on a variable in |
| its output interface. |
| endif::VK_NV_mesh_shader[] |
| |
| 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 controlling 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. |
| |
| ifdef::VKSC_VERSION_1_0[] |
| Pipeline JSON Schema:: |
| A JSON-based representation for encapsulating all pipeline state which |
| is necessary for the offline pipeline cache compiler. |
| This includes the SPIR-V shader module, pipeline layout, render pass |
| information and pipeline state creation information. |
| endif::VKSC_VERSION_1_0[] |
| |
| Pipeline Layout:: |
| An object defining 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. |
| |
| ifdef::VK_KHR_pipeline_library[] |
| Pipeline Library:: |
| A pipeline that cannot be directly used, instead defining a set of |
| shaders and shader groups which will be <<pipelines-library,linked into |
| other pipelines>>. |
| endif::VK_KHR_pipeline_library[] |
| |
| Pipeline Stage:: |
| A logically independent execution unit that performs some of the |
| operations defined by an action command. |
| |
| ifdef::VKSC_VERSION_1_0[] |
| Pipeline Identifier:: |
| An identifier that can be used to identify a specific pipeline |
| independently from the pipeline description. |
| endif::VKSC_VERSION_1_0[] |
| |
| ifdef::VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing[] |
| Pipeline Trace Ray Instruction:: |
| A ray tracing instruction which traces a ray into an acceleration |
| structure when using ray tracing pipelines. |
| One of |
| ifdef::VK_NV_ray_tracing[code:OpTraceNV,] |
| ifdef::VK_NV_ray_tracing_motion_blur[code:OpTraceRayMotionNV, code:OpTraceMotionNV,] |
| ifdef::VK_KHR_ray_tracing_pipeline[code:OpTraceRayKHR] |
| . |
| endif::VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing[] |
| |
| 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 components necessary 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 |
| components across multiple image planes. |
| The host-accessible properties of each image plane are accessible for 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 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. |
| |
| Potential Format Features:: |
| The union of all elink:VkFormatFeatureFlagBits that the implementation |
| supports for a specified elink:VkFormat, over all supported image |
| tilings. |
| ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] |
| For <<memory-external-android-hardware-buffer-external-formats,Android |
| external formats>> the elink:VkFormatFeatureFlagBits is provided by the |
| implementation. |
| endif::VK_ANDROID_external_memory_android_hardware_buffer[] |
| ifdef::VK_QNX_external_memory_screen_buffer[] |
| For <<memory-external-screen-buffer-external-formats,QNX Screen external |
| formats>> the elink:VkFormatFeatureFlagBits is provided by the |
| implementation. |
| endif::VK_QNX_external_memory_screen_buffer[] |
| |
| Pre-rasterization:: |
| Operations that execute before <<primsrast,rasterization>>, and any |
| state associated with those operations. |
| |
| 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. |
| |
| ifdef::VK_NV_mesh_shader,VK_EXT_mesh_shader[] |
| Primitive Shading Pipeline:: |
| A graphics pipeline where input primitives are assembled by fixed |
| function processing. |
| It is the counterpart to mesh shading. |
| endif::VK_NV_mesh_shader,VK_EXT_mesh_shader[] |
| |
| Primitive Topology:: |
| State controlling how vertices are assembled into primitives, e.g. as |
| lists of triangles, strips of lines, etc. |
| |
| Promoted (feature):: |
| A feature from an older extension is considered promoted if it is made |
| available as part of a new core version or newer extension with wider |
| support. |
| |
| 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 specifying 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 containing 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. |
| |
| ifdef::VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing[] |
| Ray Tracing Command:: |
| Commands that provoke work using a ray tracing pipeline. |
| Includes |
| ifdef::VK_NV_ray_tracing[flink:vkCmdTraceRaysNV,] |
| ifdef::VK_KHR_ray_tracing_pipeline[flink:vkCmdTraceRaysKHR, and flink:vkCmdTraceRaysIndirectKHR] |
| . |
| endif::VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing[] |
| |
| ifdef::VK_KHR_video_queue[] |
| Reconstructed Picture:: |
| A video picture resource reconstructed from a compressed bitstream using |
| video decode or encode operations that can: be used as a reference |
| picture by future video decode or encode operations with the same video |
| session. |
| endif::VK_KHR_video_queue[] |
| |
| Recording State (Command Buffer):: |
| A command buffer that is ready to record commands. |
| See also Initial State and Executable State. |
| |
| ifdef::VK_KHR_video_queue[] |
| Reference Picture:: |
| A video picture resource used by video decode and encode operations to |
| provide predictions of the values of samples in the subsequently decoded |
| or encoded pictures. |
| |
| Reference Picture Metadata:: |
| Opaque state associated with a DPB slot, maintained by a video session. |
| endif::VK_KHR_video_queue[] |
| |
| 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 <<extendingvulkan-extensions-extensiondependencies, 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[] |
| |
| Sample Index:: |
| The index of a sample within a <<primsrast-multisampling-coverage-mask, |
| single set of samples>>. |
| |
| Sample Shading:: |
| Invoking the fragment shader multiple times per fragment, with the |
| covered samples partitioned among the invocations. |
| |
| 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 containing state controlling 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. |
| |
| ifdef::VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing[] |
| Shader Call:: |
| An <<ray-tracing-shader-call,instruction>> which may: cause execution to |
| continue in a different shader stage. |
| endif::VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing[] |
| |
| Shader Code:: |
| A stream of instructions used to describe the operation of a shader. |
| |
| ifdef::VK_NV_device_generated_commands,VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline[] |
| Shader Group:: |
| A set of Shader Stages that are part of a slink:VkPipeline containing |
| multiple of such sets. |
| This allows the device to make use of all the shader groups from the |
| bound pipeline independently. |
| endif::VK_NV_device_generated_commands,VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline[] |
| |
| 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_fragment_shading_rate,VK_NV_shading_rate_image[] |
| [[glossary-shading-rate]] |
| Shading Rate:: |
| The ratio of the number of fragment shader invocations generated in a |
| fully covered framebuffer region to the size (in pixels) of that region. |
| endif::VK_KHR_fragment_shading_rate,VK_NV_shading_rate_image[] |
| |
| ifdef::VK_NV_shading_rate_image[] |
| [[glossary-shading-rate-image]] |
| Shading Rate Image:: |
| An image used to establish the shading rate for a framebuffer region, |
| where each pixel controls the shading rate for a corresponding |
| framebuffer region. |
| endif::VK_NV_shading_rate_image[] |
| |
| 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::VKSC_VERSION_1_0[] |
| Single Event Upset:: |
| A change of physical device state, such as a register or memory bitflip, |
| e.g. caused by ionizing radiation. |
| endif::VKSC_VERSION_1_0[] |
| |
| 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 texel block size of the uncompressed |
| format must: equal the 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 defining 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. |
| |
| ifdef::VK_NV_ray_tracing_motion_blur[] |
| SRT:: |
| A decomposition of a spatial transform separating out scale, rotation, |
| and translation which has better linear interpolation properties for |
| representing motion. |
| endif::VK_NV_ray_tracing_motion_blur[] |
| |
| 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. |
| A reference in the entry point's interface list does not constitute a |
| static use. |
| 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_VERSION_1_1,VK_EXT_shader_subgroup_vote[] |
| 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_VERSION_1_1,VK_EXT_shader_subgroup_vote[] |
| |
| ifdef::VK_VERSION_1_1,VK_EXT_shader_subgroup_ballot[] |
| 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_VERSION_1_1,VK_EXT_shader_subgroup_ballot[] |
| |
| 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, |
| ifdef::VK_VERSION_1_2,VK_KHR_depth_stencil_resolve[] |
| depth/stencil resolve, |
| endif::VK_VERSION_1_2,VK_KHR_depth_stencil_resolve[] |
| 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 Block:: |
| A single addressable element of an image with an uncompressed |
| elink:VkFormat, or a single compressed block of an image with a |
| compressed elink:VkFormat. |
| |
| Texel Block Size:: |
| The size (in bytes) used to store a texel block of a compressed or |
| uncompressed image. |
| |
| Texel Coordinate System:: |
| One of three coordinate systems (normalized, unnormalized, integer) |
| defining how texel coordinates are interpreted in an image or a specific |
| mipmap level of an image. |
| |
| ifdef::VK_EXT_shader_tile_image[] |
| [[glossary-tile-image]] |
| Tile Image:: |
| A per-tile view of a framebuffer attachment. |
| If the `apiext:VK_EXT_shader_tile_image` extension is enabled, the |
| framebuffer is considered to be divided into tiles. |
| |
| endif::VK_EXT_shader_tile_image[] |
| |
| ifdef::VK_VERSION_1_2,VK_KHR_timeline_semaphore[] |
| Timeline Semaphore:: |
| A semaphore with a strictly increasing 64-bit unsigned integer payload |
| indicating whether the semaphore is signaled with respect to a |
| particular reference value. |
| Represented by a slink:VkSemaphore object created with a semaphore type |
| of ename:VK_SEMAPHORE_TYPE_TIMELINE. |
| endif::VK_VERSION_1_2,VK_KHR_timeline_semaphore[] |
| |
| 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_transform_feedback[] |
| Vertex Stream:: |
| A vertex stream is where the last |
| <<pipelines-graphics-subsets-pre-rasterization,pre-rasterization shader |
| stages>> outputs vertex data, which then goes to the rasterizer, is |
| captured to a transform feedback buffer, or both. |
| Geometry shaders can: emit primitives to multiple independent vertex |
| streams. |
| Each vertex emitted by the geometry shader is directed at one of the |
| vertex streams. |
| endif::VK_EXT_transform_feedback[] |
| |
| 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[] |
| |
| Variable-Sized Descriptor Binding:: |
| A descriptor binding whose size will be specified when a descriptor set |
| is allocated using this layout. |
| |
| 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. |
| |
| ifdef::VK_KHR_video_queue[] |
| Video Bitstream Buffer:: |
| A resource that represents a linear array of data in device memory |
| storing encoded video data. |
| Represented by a slink:VkBuffer object. |
| |
| Video Coding Scope:: |
| A series of subsequent commands recorded into a command buffer starting |
| with a flink:vkCmdBeginVideoCodingKHR command and ending with a |
| flink:vkCmdEndVideoCodingKHR command that encompasses a set of video |
| decode or encode operations. |
| |
| Video Coding Operations:: |
| Any operations recorded into a command buffer within a video coding |
| scope, including video decode and encode operations. |
| |
| Video Decode Operation:: |
| An operation consuming data from a video bitstream buffer and zero or |
| more reference pictures, and producing data to a decode output picture |
| and an optional reconstructed picture. |
| |
| Video Encode Operation:: |
| An operation consuming data from an encode input picture and zero or |
| more reference pictures, and producing data to a video bitstream buffer |
| and an optional reconstructed picture. |
| |
| Video Picture Resource:: |
| A resource that represents a multi-dimensional formatted interpretation |
| of device memory to be used with a video session as a decode output |
| picture, encode input picture, reconstructed picture, and/or reference |
| picture. |
| It may: contain metadata associated with a particular video session it |
| is used with. |
| Represented by a slink:VkImage object and referred to using |
| slink:VkImageView objects created from it. |
| |
| Video Session:: |
| A resource that represents and maintains the state needed to perform |
| video decode or encode operations. |
| Represented by a slink:VkVideoSessionKHR object. |
| |
| Video Session Parameters:: |
| A resource that stores preprocessed codec-specific parameters used with |
| a compatible video session in video codec operations. |
| Represented by a slink:VkVideoSessionParametersKHR object. |
| |
| Video Transcoding:: |
| The process of using the outputs of video decoding operations as inputs |
| in video encoding operations. |
| endif::VK_KHR_video_queue[] |
| |
| 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>> |
| |
| |
| [[lexicon-common-abbreviations]] |
| == Common Abbreviations |
| |
| The abbreviations and acronyms defined in this section are sometimes used in |
| the Specification and the API where they are considered clear and |
| commonplace. |
| |
| Src:: |
| Source |
| |
| Dst:: |
| Destination |
| |
| Min:: |
| Minimum |
| |
| Max:: |
| Maximum |
| |
| Rect:: |
| Rectangle |
| |
| Info:: |
| Information |
| |
| LOD:: |
| Level of Detail |
| |
| Log:: |
| Logarithm |
| |
| ID:: |
| Identifier |
| |
| UUID:: |
| Universally Unique Identifier |
| |
| Op:: |
| Operation |
| |
| R:: |
| Red color component |
| |
| G:: |
| Green color component |
| |
| B:: |
| Blue color component |
| |
| A:: |
| Alpha color component |
| |
| RTZ:: |
| Round towards zero |
| |
| RTE:: |
| Round to nearest even |
| |
| |
| ifdef::VK_KHR_video_queue[] |
| [[lexicon-video-abbreviations]] |
| == Video-Specific Abbreviations |
| |
| The following abbreviations and acronyms are used in the context of video |
| decode and encode operations to refer to commonly used video compression |
| terms in their usual abbreviated form: |
| |
| AVC:: |
| Advanced Video Coding |
| |
| Bipred:: |
| Bidirectional Prediction |
| |
| CABAC:: |
| Context-Adaptive Binary Arithmetic Coding |
| |
| CAVLC:: |
| Context-Adaptive Variable-Length Coding |
| |
| CBR:: |
| Constant Bit Rate |
| |
| CTB:: |
| Coding Tree Block |
| |
| Diff:: |
| Difference |
| |
| DPB:: |
| Decoded Picture Buffer |
| |
| GOP:: |
| Group Of Pictures |
| |
| HDR:: |
| High Dynamic Range |
| |
| HEVC:: |
| High Efficiency Video Coding |
| |
| HRD:: |
| Hypothetical Reference Decoder |
| |
| IDC:: |
| Indicator |
| |
| IDR:: |
| Instantaneous Decoder Refresh |
| |
| MB:: |
| Macroblock |
| |
| MV:: |
| Motion Vector |
| |
| NALU:: |
| Network Abstraction Layer Unit |
| |
| PCM:: |
| Pulse-Code Modulation |
| |
| Pic:: |
| Picture |
| |
| Pred:: |
| Prediction |
| |
| PPS:: |
| Picture Parameter Set |
| |
| QP:: |
| Quantization Parameter |
| |
| RC:: |
| Rate Control |
| |
| SPS:: |
| Sequence Parameter Set |
| |
| Std:: |
| Standard |
| |
| VBR:: |
| Variable Bit Rate |
| |
| VCL:: |
| Video Coding Layer |
| |
| VPS:: |
| Video Parameter Set |
| endif::VK_KHR_video_queue[] |
| |
| |
| [[lexicon-prefixes]] |
| == 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 |
