Data Type (GLSL)
The OpenGL Shading Language defines a number of types. It also defines the means by which users can define types.
Contents
Basic types
Scalars
The basic nonvector types are:
 bool: conditional type, values may be either
true
orfalse
 int: a signed integer
 uint: an unsigned integer
 float: a floating point number
 double: a doubleprecision floatingpoint number
Vectors
Each of the scalar types, including booleans, have 2, 3, and 4component vector equivalents. The n digit below can be 2, 3, or 4:
 bvecn: a vector of booleans
 ivecn: a vector of signed integers
 uvecn: a vector of unsigned integers
 vecn: a vector of singleprecision floatingpoint numbers
 dvecn: a vector of doubleprecision floatingpoint numbers
Vector values can have the same math operators applied to them that scalar values do. These all perform the componentwise operations on each component. However, in order for these operators to work on vectors, the two vectors must have the same number of components.
Swizzling
You can access the components of vectors using the following syntax:
vec4 someVec; someVec.x + someVec.y;
This is called swizzling. You can use x, y, z, or w, referring to the first, second, third, and fourth components, respectively.
The reason it has that name "swizzling" is because the following syntax is entirely valid:
vec2 someVec; vec4 otherVec = someVec.xyxx; vec3 thirdVec = otherVec.zyy;
You can use any combination of up to 4 of the letters to create a vector (of the same basic type) of that length. So otherVec.zyy
is a vec3, which is how we can initialize a vec3 value with it. Any combination of up to 4 letters is acceptable, so long as the source vector actually has those components. Attempting to access the 'w' component of a vec3 for example is a compiletime error.
Additionally, there are 3 sets of swizzle masks. You can use xyzw, rgba (for colors), or stpq (for texture coordinates). These three sets have no actual difference; they're just syntactic sugar.
Matrices
In addition to vectors, there are also matrix types. All matrix types are floatingpoint, either singleprecision or doubleprecision. Matrix types are as follows, where n and m can be the numbers 2, 3, or 4:

matnxm
: A matrix with n columns and m rows. OpenGL uses columnmajor matrices, which is standard for mathematics users. Example:mat3x4
. 
matn
: A symmetric matrix with n columns and rows. This type is equivalent tomatnxn
.
Doubleprecision matrices (GL 4.0 and above) can be declared with a dmat
instead of mat
Swizzling does not work with matrices. You can instead access a matrix's fields with array syntax:
mat3 theMatrix; theMatrix[1] = vec3(3.0, 3.0, 3.0); //Sets the second column to all 3.0s theMatrix[2][0] = 16.0; //Sets the first entry of the third column to 16.0.
Samplers
Texture access is not as simple as reading a value from a memory address. Filtering and other processes are applied to textures, and how texture coordinates are interpreted can be part of the texture access operation. For these reason, texture access is somewhat complicated.
It starts with samplers, a special type that GLSL defines. Each sampler variable represents a texture that is attached to the context. Samplers have a type that defines what kind of texture can be attached to them.
Sampler types cannot be initialized to a value. They cannot have any operations executed on them. They can only be passed as parameters to functions, and variables of sampler types can only be global uniforms (declared outside of interface blocks or as input parameters to functions.
Implicit conversion
Certain values can be implicitly converted to certain types. This means that an explicit construction operation is not necessary.
Signed integers can be implicitly converted to unsigned integers, but the reverse is not true. Either integer type can be converted into floats, and integers and floats can be converted into doubles.
Vector and matrix values are implicitly converted if the basic type they contain is implicitly convertible.
Arrays
Basic types can be grouped into sequences of those elements, called arrays. This generally works like in C/C++, but there are some limitations.
Arrays usually must be declared with a size. Input arrays to geometry shaders do not need a size. Global variables can be declared without a size, but only if they are later redeclared with a size.
The array size must be a compiletime integral constant expression.
With a few exceptions, arrays can be used for all of the storage qualifiers: inputs, outputs, uniforms, constants, etc. Outputs from the fragment shader cannot be arrays.
The length of an array variable can be computed with the .length()
function. For example:
uniform float myValues[12];
...
myValues.length(); //Returns 12.
Arrays can be accessed with arbitrary numeric expressions. They do not have to be compiletime constants (though there are a few exceptions to this rule).
Sampler arrays
Arrays of sampler types are special. Under GLSL version 3.30, sampler arrays can be declared, but they can only be accessed by compiletime integral constant expressions. So you cannot loop over an array of samplers.
Under GLSL 4.00 and above, sampler arrays can be accessed by noncompiletime constants, but there are still limitations. The value must be "dynamically uniform." This means that the value used to access sampler arrays must be the same, in the same execution order, regardless of any nonuniform parameter values. So the index must be either a compiletime constant, a uniform variable, or an expression composed of only compiletime constants and uniform variables.
For example, in 4.00, it is legal to loop over an array of samplers, so long as the loop index is based on constants and uniforms. So this is legal:
uniform sampler images[10];
uniform int imageCount;
void main()
{
vec4 accum = vec4(0.0);
for(int i = 0; i < imageCount; i++)
{
accum += texture(images[i], ...);
}
}
This would add up all of the values in the textures, up to imageCount in size. Note that this is not legal in GLSL 3.30.
Structs
Structs are defined much like C++ (note: the common typedef struct *{} syntax from standard C is not supported). GLSL does not support anonymous structures (ie: structs without a type name), and structs must have at least one member declaration. Structs cannot be defined within another struct.
struct Light
{
vec3 eyePosOrDir;
bool isDirectional;
vec3 intensity;
float attenuation;
} variableName;
The above definition not only defines a struct type Light, it also creates a variable of that type called variableName. As in C/C++, the variable name can be omitted.
Structs cannot contain variables of sampler types. They can contain variables of other struct types.
Structs define a named type. But there are limits on the type qualifiers that can be used with struct types. Uniforms can use struct types, as well as regular globals, locals, and constant variables. Structs cannot be used with any other storage qualifiers.
Struct fields are accessed using the standard "." syntax from C/C++.
Structs can be passed as function parameters.
Constructors and initializers
Variables of almost types can be initialized with an initial value. The exceptions are:
 Input or output qualified variables.
 Any variable of a sampler type.
 Uniform variables declared in a uniform block.
those that use input or output qualifiers and all variables of sampler types.
For basic types, the variable can be initialized by setting it equal to a literal value:
uniform int aValue = 5;
Note that initializing a uniform only sets that variable at the moment that the program object is successfully compiled and linked. The user can override this value by manually setting that uniform value.
Literals
A literal is a value written into the shader. Literals are always basic types, and they can be used to initialize the value of a basic type. They can also be used wherever a constant basic value is needed.
Literals are typed. There are two literals of bool type: true
and false
.
Any integer value is by default of type int (a signed integer). To create an integer literal of unsigned type, use the suffix u
or U
.
Integer literals can be defined in base 8 or base 16 using the standard C/C++ conventions (prefix with 0 for base 8 or 0x for base 16).
A numeric literal that uses a decimal is by default of type float. To create a float literal from an integer value, use the suffix f
or F
as in C/C++.
Floats can also be defined using exponential notation, using the e
or E
to separate the base from the exponent. The exponent is always base10.
In GLSL 4.00 and above, doubleprecision floats are available. By default, all floatingpoint literals are of type float. To create a doubleprecision float, use the lf
or LF
suffixes. This will force it to the double type.
Constructors
Types more complex than the base types are initialized with constructors. All constructors take the form:
typename(value1, value2, ...)
The typename is the name of the type to construct. The values can be literals, previouslydefined variables, and other constructors.
Some constructors have special syntax.
Vector constructors
Vector constructors take the number of values that they store. So a vec3 takes 3 values. However, all vectors can be constructed from a single value; this results in a vector where all of the values are the value given to the constructor. So:
vec3(1.0) == vec3(1.0, 1.0, 1.0);
Vectors can also be constructed from other vectors, or a combination of vectors and scalars. The values in the output vector are filled in, right to left, by the values in the input scalars and vectors. There must be enough values, counting scalars and vectors, to fill in all of the elements of the output vector. Here are some examples:
vec4(vec2(10.0, 11.0), 1.0, 3.5) == vec4(10.0, vec2(11.0, 1.0), 3.5); vec3(vec4(1.0, 2.0, 3.0, 4.0) == vec3(1.0, 2.0, 3.0); vec4(vec3(1.0, 2.0, 3.0)); //error. Not enough components. vec2(vec3(1.0, 2.0, 3.0)); //error. Too many components.
Matrix constructors
For matrices, construction is rather more complicated.
If a matrix is constructed with a single scalar value, then that value is used to initialize all the values along the diagonal of the matrix; the rest are given zeros. Therefore, mat4(1.0)
is a 4x4 identity matrix.
For more values, matrices are filled in in columnmajor order. That is, the first X values are the first column, the second X values are the next column, and so forth. Examples:
mat2(
float, float, //first column
float, float); //second column
mat4(
vec4, //first column
vec4, //second column
vec4, //third column
vec4); //fourth column
mat3(
vec2, float, //first column
vec2, float, //second column
vec2, float); //third column
Matrices can be constructed from other matrices as well. A matrix can only be constructed from a single other matrix. The column and row values from the input matrix are copied to their corresponding values in the output; any values of the output not filled in are filled with the identity matrix.
Therefore:
mat3 diagMatrix = mat3(5.0); //Diagonal matrix with 5.0 on the diagonal. mat4 otherMatrix = mat4(diagMatrix);
The otherMatrix is a diagonal matrix, where the first 3 values are 5.0, and the last diagonal value is 1.0.
There are no restrictions on size when doing matrix construction from another matrix. So you can construct a 4x2 matrix from a 2x4 matrix; only the corresponding elements are copied.
Array constructors
Arrays can be constructed using array constructor syntax. In this case, the type also contains the [] array notation:
const float array[3] = float[3](2.5, 7.0, 1.5);
The size is not necessary for array constructors, as the size is implicitly specified by the number of arguments to the constructor.
Struct constructors
Structs are constructed by filling in their values in the order in which they are defined. For example:
struct Data
{
float first;
vec2 second;
};
Data dataValue = Data(1.4, vec2(16.0, 22.5));
Notice the vector constructor in the middle of the struct constructor. Constructors can be nested. So if you have an array of structs of the above type, you can construct it as follows:
Data dataArray[3] = Data[3](
Data(1.0, vec2(19.0, 4.5)),
Data(3.0, vec2(2.718, 2.0)),
Data(29.5, vec2(3.142, 3.333)));