Vertex shaders can define input variables, which receive vertex attribute
data transferred from one or more VkBuffer
(s) by drawing commands.
Vertex shader input variables are bound to buffers via an indirect binding
where the vertex shader associates a vertex input attribute number with
each variable, vertex input attributes are associated to vertex input
bindings on a per-pipeline basis, and vertex input bindings are associated
with specific buffers on a per-draw basis via the
vkCmdBindVertexBuffers
command. Vertex input attribute and vertex
input binding descriptions also contain format information controlling how
data is extracted from buffer memory and converted to the format expected by
the vertex shader.
There are VkPhysicalDeviceLimits
::maxVertexInputAttributes
number of vertex input attributes and
VkPhysicalDeviceLimits
::maxVertexInputBindings
number of
vertex input bindings (each referred to
by zero-based indices), where there are at least as many vertex input
attributes as there are vertex input bindings. Applications can store
multiple vertex input attributes interleaved in a single buffer, and use a
single vertex input binding to access those attributes.
In GLSL, vertex shaders associate input variables with a vertex input
attribute number using the location
layout qualifier. The
component
layout qualifier associates components of a vertex shader
input variable with components of a vertex input attribute.
GLSL example.
// Assign location M to variableName layout (location=M, component=2) in vec2 variableName; // Assign locations [N,N+L) to the array elements of variableNameArray layout (location=N) in vec4 variableNameArray[L];
In SPIR-V, vertex shaders associate input variables with a vertex input
attribute number using the Location
decoration. The Component
decoration associates components of a vertex shader input variable with
components of a vertex input attribute. The Location
and Component
decorations are specified via the OpDecorate
instruction.
SPIR-V example.
... %1 = OpExtInstImport "GLSL.std.450" ... OpName %9 "variableName" OpName %15 "variableNameArray" OpDecorate %18 Builtin VertexIndex OpDecorate %19 Builtin InstanceIndex OpDecorate %9 Location M OpDecorate %9 Component 2 OpDecorate %15 Location N ... %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 2 %8 = OpTypePointer Input %7 %9 = OpVariable %8 Input %10 = OpTypeVector %6 4 %11 = OpTypeInt 32 0 %12 = OpConstant %11 L %13 = OpTypeArray %10 %12 %14 = OpTypePointer Input %13 %15 = OpVariable %14 Input ...
Vertex shaders allow Location
and Component
decorations on
input variable declarations. The Location
decoration specifies which
vertex input attribute is used to read and interpret the data that
a variable will consume. The Component
decoration allows the location
to be more finely specified for scalars and vectors, down to the
individual components within a location that are consumed. The
components within a location are 0, 1, 2, and 3. A variable starting
at component N will consume components N, N+1, N+2, … up through
its size. For single precision types, it is invalid if the sequence
of components gets larger than 3.
When a vertex shader input variable declared using a scalar or vector
32-bit data type is assigned a location, its value(s) are taken from
the components of the input attribute specified with the corresponding
VkVertexInputAttributeDescription
::location
.
The components used depend on the type of variable and the
Component
decoration specified in the variable declaration,
as identified in Table 20.1, “Input attribute components accessed by 32-bit input variables”. Any 32-bit scalar
or vector input will consume a single location. For 32-bit data types,
missing components are filled in with default values as described
below.
Table 20.1. Input attribute components accessed by 32-bit input variables
32-bit data type | Component decoration | Components consumed |
---|---|---|
scalar | 0 or unspecified | (x, o, o, o) |
scalar | 1 | (o, y, o, o) |
scalar | 2 | (o, o, z, o) |
scalar | 3 | (o, o, o, w) |
two-component vector | 0 or unspecified | (x, y, o, o) |
two-component vector | 1 | (o, y, z, o) |
two-component vector | 2 | (o, o, z, w) |
three-component vector | 0 or unspecified | (x, y, z, o) |
three-component vector | 1 | (o, y, z, w) |
four-component vector | 0 or unspecified | (x, y, z, w) |
Components indicated by ‘o’ are available for use by other input variables which are sourced from the same attribute, and if used, are either filled with the corresponding component from the input format (if present), or the default value.
When a vertex shader input variable declared using a 32-bit floating point
matrix type is assigned a location i, its values are taken from
consecutive input attributes starting with the corresponding
VkVertexInputAttributeDescription
::location
. Such matrices are
treated as an array of column vectors with values taken from the input
attributes identified in Table 20.2, “Input attributes accessed by 32-bit input matrix variables”. The
VkVertexInputAttributeDescription
::format
must be specified
with a VkFormat
that corresponds to the appropriate type of column
vector. The Component
decoration must not be used with matrix types.
Table 20.2. Input attributes accessed by 32-bit input matrix variables
Data type | Column vector type | Locations consumed | Components consumed |
---|---|---|---|
mat2 | two-component vector | i, i+1 | (x, y, o, o), (x, y, o, o) |
mat2x3 | three-component vector | i, i+1 | (x, y, z, o), (x, y, z, o) |
mat2x4 | four-component vector | i, i+1 | (x, y, z, w), (x, y, z, w) |
mat3x2 | two-component vector | i, i+1, i+2 | (x, y, o, o), (x, y, o, o), (x, y, o, o) |
mat3 | three-component vector | i, i+1, i+2 | (x, y, z, o), (x, y, z, o), (x, y, z, o) |
mat3x4 | four-component vector | i, i+1, i+2 | (x, y, z, w), (x, y, z, w), (x, y, z, w) |
mat4x2 | two-component vector | i, i+1, i+2, i+3 | (x, y, o, o), (x, y, o, o), (x, y, o, o), (x, y, o, o) |
mat4x3 | three-component vector | i, i+1, i+2, i+3 | (x, y, z, o), (x, y, z, o), (x, y, z, o), (x, y, z, o) |
mat4 | four-component vector | i, i+1, i+2, i+3 | (x, y, z, w), (x, y, z, w), (x, y, z, w), (x, y, z, w) |
Components indicated by ‘o’ are available for use by other input variables which are sourced from the same attribute, and if used, are either filled with the corresponding component from the input (if present), or the default value.
When a vertex shader input variable declared using a scalar or vector
64-bit data type is assigned a location i, its values are taken from
consecutive input attributes starting with the corresponding
VkVertexInputAttributeDescription
::location
. The locations
and components used depend on the type of variable and the Component
decoration specified in the variable declaration, as identified in
Table 20.3, “Input attribute locations and components accessed by 64-bit input variables”. For 64-bit data types, no default
attribute values are provided. Input variables must not use more
components than provided by the attribute. Input attributes which have
one- or two-component 64-bit formats will consume a single location.
Input attributes which have three- or four-component 64-bit formats
will consume two consecutive locations. A 64-bit scalar
data type will consume two components, and a 64-bit two-component
vector data type will consume all four components available within
a location. A three- or four-component 64-bit data type must not
specify a component. A three-component 64-bit data type will consume
all four components of the first location and components 0 and 1 of
the second location. This leaves components 2 and 3 available for
other component-qualified declarations. A four-component 64-bit
data type will consume all four components of the first location
and all four components of the second location. It is invalid for
a scalar or two-component 64-bit data type to specify a component
of 1 or 3.
Table 20.3. Input attribute locations and components accessed by 64-bit input variables
Input format | Locations consumed | 64-bit data type | Location decoration | Component decoration | 32-bit components consumed |
---|---|---|---|---|---|
R64 | i | scalar | i | 0 or unspecified | (x, y, -, -) |
R64G64 | i | scalar | i | 0 or unspecified | (x, y, o, o) |
scalar | i | 2 | (o, o, z, w) | ||
two-component vector | i | 0 or unspecified | (x, y, z, w) | ||
R64G64B64 | i, i+1 | scalar | i | 0 or unspecified | (x, y, o, o), (o, o, -, -) |
scalar | i | 2 | (o, o, z, w), (o, o, -, -) | ||
scalar | i+1 | 0 or unspecified | (o, o, o, o), (x, y, -, -) | ||
two-component vector | i | 0 or unspecified | (x, y, z, w), (o, o, -, -) | ||
three-component vector | i | unspecified | (x, y, z, w), (x, y, -, -) | ||
R64G64B64A64 | i, i+1 | scalar | i | 0 or unspecified | (x, y, o, o), (o, o, o, o) |
scalar | i | 2 | (o, o, z, w), (o, o, o, o) | ||
scalar | i+1 | 0 or unspecified | (o, o, o, o), (x, y, o, o) | ||
scalar | i+1 | 2 | (o, o, o, o), (o, o, z, w) | ||
two-component vector | i | 0 or unspecified | (x, y, z, w), (o, o, o, o) | ||
two-component vector | i+1 | 0 or unspecified | (o, o, o, o), (x, y, z, w) | ||
three-component vector | i | unspecified | (x, y, z, w), (x, y, o, o) | ||
four-component vector | i | unspecified | (x, y, z, w), (x, y, z, w) |
Components indicated by ‘o’ are available for use by other input variables which are sourced from the same attribute. Components indicated by ‘-’ are not available for input variables as there are no default values provided for 64-bit data types, and there is no data provided by the input format.
When a vertex shader input variable declared using a 64-bit floating-point matrix type is assigned a location i, its values are taken from consecutive input attribute locations. Such matrices are treated as an array of column vectors with values taken from the input attributes as shown in Table 20.3, “Input attribute locations and components accessed by 64-bit input variables”. Each column vector starts at the location immediately following the last location of the previous column vector. The number of attributes and components assigned to each matrix is determined by the matrix dimensions and ranges from two to eight locations.
When a vertex shader input variable declared using an array type
is assigned a location, its values are taken from consecutive
input attributes starting with the corresponding
VkVertexInputAttributeDescription
::location
. The number
of attributes and components assigned to each element are determined
according to the data type of the array elements and Component
decoration (if any) specified in the declaration of the array, as described
above. Each element of the array, in order, is assigned to consecutive
locations, but all at the same specified component within each location.
Only input variables declared with the data types and component decorations as specified above are supported. Location aliasing is causing two variables to have the same location number. Component aliasing is assigning the same (or overlapping) component number for two location aliases. Location aliasing is allowed only if it does not cause component aliasing. Further, when location aliasing, the aliases sharing the location must all have the same SPIR-V floating-point component type or all have the same width integer-type components.