Mathematics is core to all of computer graphics. In earlier versions, OpenGL provided support for managing coordinate transformations and projections using the standard matrix stacks (`GL_MODELVIEW`

and `GL_PROJECTION`

). In core OpenGL 4.0, however, all of the functionality supporting the matrix stacks has been removed. Therefore, it is up to us to provide our own support for the usual transformation and projection matrices, and then to pass them into our shaders. Of course, we could write our own matrix and vector classes to manage this, but if you're like me, you prefer to use a ready-made, robust library.

One such library is GLM (OpenGL Mathematics) written by Christophe Riccio. Its design is based on the GLSL specification, so the syntax is very similar to the mathematical support in GLSL. For experienced GLSL programmers, this makes it very easy to use. Additionally, it provides extensions that include functionality similar to some of the much-missed OpenGL functions such as `glOrtho`

,
`glRotate`

, or `gluLookAt`

.

Download the latest GLM distribution from http://glm.g-truc.net. Unzip the archive file, and copy the `glm`

directory contained inside to anywhere in your compiler's include path.

Using the GLM libraries is simply a matter of including the core header file (highlighted in the following code snippet) and headers for any extensions. We'll include the matrix transform extension, and the `transform2`

extension.

**#include <glm/glm.hpp>**
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/transform2.hpp>

The GLM classes are then available in the `glm`

namespace. The following is an example of how you might go about making use of some of them.

glm::vec4 position = glm::vec4( 1.0f, 0.0f, 0.0f, 1.0f ); glm::mat4 view = glm::lookAt( glm::vec3(0.0,0.0,5.0), glm::vec3(0.0,0.0,0.0), glm::vec3(0.0,1.0,0.0) ); glm::mat4 model = glm::mat4(1.0f); model = glm::rotate( model, 90.0f, glm::vec3(0.0f,1.0f,0.0) ); glm::mat4 mv = view * model; glm::vec4 transformed = mv * position;

The GLM library is a header-only library. All of the implementation is included within the header files. It doesn't require separate compilation and you don't need to link your program to it. Just placing the header files in your include path is all that's required!

The preceding example first creates a `vec4`

(four coordinate vector) representing a position. Then it creates a 4x4 view matrix by using the
`glm::lookAt`

function from the `transform2`

extension. This works in a similar fashion to the old `gluLookAt`

function. In this example, we set the camera's location at (0,0,5), looking towards the origin, with the "up" direction in the direction of the Y-axis. We then go on to create the modeling matrix by first storing the identity matrix in the variable `model`

(via the constructor: `glm::mat4(1.0f)`

), and multiplying by a rotation matrix using the `glm::rotate`

function. The multiplication here is implicitly done by the `glm::rotate`

function. It multiplies its first parameter by the rotation matrix that is generated by the function. The second parameter is the angle of rotation (in degrees), and the third parameter is the axis of rotation. The net result is a rotation matrix of 90 degrees around the Y-axis.

Finally, we create our model view matrix (`mv`

) by multiplying the `view`

and `model`

variables, and then using the combined matrix to transform the position. Note that the multiplication operator has been overloaded to behave in the expected way.

As stated above, the GLM library conforms as closely as possible to the GLSL specification, with additional features that go beyond what you can do in GLSL. If you are familiar with GLSL, GLM should be easy and natural to use.

### Note

Swizzle operators (selecting components using commands like: `foo.x`

, `foo.xxy`

, and so on) are disabled by default in GLM. You can selectively enable them by defining `GLM_SWIZZLE`

before including the main GLM header. The GLM manual has more detail. For example, to enable all swizzle operators you would do the following:

#define GLM_SWIZZLE #include <glm/glm.hpp>

It is *not* recommended to import all of the GLM namespace using a command like:

This will most likely cause a number of namespace clashes. Instead, it is preferable to import symbols one at a time, as needed. For example:

#include <glm/glm.hpp> using glm::vec3; using glm::mat4;

GLM supports directly passing a GLM type to OpenGL using one of the OpenGL vector functions (with the suffix "v"). For example, to pass a `mat4`

named `proj`

to OpenGL we can use the following code:

#include <glm/glm.hpp> #include <glm/gtc/matrix_transform.hpp> ... glm::mat4 proj = glm::perspective( viewAngle, aspect, nearDist, farDist ); glUniformMatrix4fv(location, 1, GL_FALSE, &proj[0][0]);

The GLM website http://glm.g-truc.net has additional documentation and examples.