GLSL 4×4 Matrix Fields

Here is a short article about manipulating GLSL mat4 fields. In C, an OpenGL 4×4 matrix is a 16-float array:

float c_matrix[16];

In GLSL the same matrix is:

mat4 glsl_matrix;

Let’s see how to map the C matrix to the GLSL one and vice-versa. Matrices in OpenGL are column-major. The c_matrix[] can be represented by:

The first column is made up of entries 0, 1, 2 and 3. The second column is 4, 5, 6, 7 and so on.

In C, the first entry of the first column is:

c_matrix[0];

While the second entry of the third column is:

c_matrix[9];

Now in GLSL. The first entry of the first column is:

glsl_matrix[0][0];

The second entry of the third column is:

glsl_matrix[2][1];

A mat4 can be seen as four vec4 vectors:

vec4 c0 = glsl_matrix[0].xyzw;
vec4 c1 = glsl_matrix[1].xyzw;
vec4 c2 = glsl_matrix[2].xyzw;
vec4 c3 = glsl_matrix[3].xyzw;

The first entry of the first column is now:

glsl_matrix[0].x;

And the second entry of the third column is:

glsl_matrix[2].y;

In the case of an object transformation matrix, the 4×4 matrix usually contains the orientation and the position of the object. The orientation is stored in the upper 3×3 matrix, or in terms of a mat4, in the three first entries of the three first columns. The position is stored in the three first entries of the fourth and last column.

Here is now a GLSL code snippet that build a 4×4 transformation matrix from a 3D position and the three Euler’s angles:

mat4 build_transform(vec3 pos, vec3 ang) 
{
  float cosX = cos(ang.x);
  float sinX = sin(ang.x);
  float cosY = cos(ang.y);
  float sinY = sin(ang.y);
  float cosZ = cos(ang.z);
  float sinZ = sin(ang.z);

  mat4 m;

  float m00 = cosY * cosZ + sinX * sinY * sinZ; 
  float m01 = cosY * sinZ - sinX * sinY * cosZ; 
  float m02 = cosX * sinY;
  float m03 = 0.0;
  
  float m04 = -cosX * sinZ; 
  float m05 = cosX * cosZ; 
  float m06 = sinX;
  float m07 = 0.0;
  
  float m08 = sinX * cosY * sinZ - sinY * cosZ;
  float m09 = -sinY * sinZ - sinX * cosY * cosZ;
  float m10 = cosX * cosY;
  float m11 = 0.0;
  
  float m12 = pos.x;
  float m13 = pos.y;
  float m14 = pos.z;
  float m15 = 1.0;

  /*
  //------ Orientation ---------------------------------
  m[0] = vec4(m00, m01, m02, m03); // first column.
  m[1] = vec4(m04, m05, m06, m07); // second column.
  m[2] = vec4(m08, m09, m10, m11); // third column.

  //------ Position ------------------------------------
  m[3] = vec4(m12, m13, m14, m15); // fourth column.
  */

  //------ Orientation ---------------------------------
  m[0][0] = m00; // first entry of the first column.
  m[0][1] = m01; // second entry of the first column.
  m[0][2] = m02;
  m[0][3] = m03;
  
  m[1][0] = m04; // first entry of the second column.
  m[1][1] = m05; // second entry of the second column.
  m[1][2] = m06;
  m[1][3] = m07;

  m[2][0] = m08; // first entry of the third column.
  m[2][1] = m09; // second entry of the third column.
  m[2][2] = m10;
  m[2][3] = m11;
  
  //------ Position ------------------------------------
  m[3][0] = m12; // first entry of the fourth column.
  m[3][1] = m13; // second entry of the fourth column.
  m[3][2] = m14;
  m[3][3] = m15;

  return m;
}

Remark: manipulating mat4 fields can be dangerous. For example this code does not generate errors nor warnings (at least with my GTX 660 on Windows) but does not work at all:

  //------ Position ------------------------------------
  m[3][0] = m12; // first entry of the fourth column.
  m[3][1] = m13; // second entry of the fourth column.
  m[3][4] = m14; // ERROR!
  m[3][3] = m15;

In the third line, we set m14 to an out of range memory location. Such kind of bugs can be hard to detect…

If you wish to quick test mat4 fields, I prepared a little GLSL Hacker demo you can find in the code sample pack (host_api/GLSL_Misc/mat4_transform/demo.xml).

Some references

• Data Type (GLSL) @ OpenGL wiki