Rotating, scaling and translating 2d points in GLM

I am currently trying to create a 2d game and I am a bit shocked that I can not find any transformations like rotation, scale, translate for vec2.

For example as far as I know rotate is only available for a mat4x4 and mat4x4 can only be multiplied by a vec4.

Is there any reason for that?

It seems that I haven’t looked hard enough

One thing that you should understand is that you can’t just ignore the z component, let alone the w component. It depends on how you want to view the problem. The problem is that you want to use a mat2 and a vec2 for 2D, but alas it’s not as simple as you may think. You are using OpenGL, and presumably it’s with shaders too. You need to use at least a glm::mat3, or better: mat4. The reason for this is that although you want everything in 2D, it has to be done in terms of 3D. 2D is really just 3D with the z-buffer being 1 and the clip pane simply static, relative to the Window size.

So, what I suggest is this:

For your model matrix, you have it as a glm::mat4 which contains all data, even if you don't intend to use it. Consistency is important here, especially for transformations.

Don't ignore the z and w component in glm::mat4; they are important because their values dictate where they are on screen. OpenGL needs to know where in the z-plane a value is. And for matrix multiplication, homogenous coordinates are required, so the w component is also important. In other words, you are virtually stuck with glm::mat4.

To get transformations for glm::mat4 you should

#include <glm/gtc/matrix_transform.hpp>

Treat your sprites separately; as in have a Sprite class, and group them outside that class. Don’t do the grouping recursively as this leads to messy code. Generating vertices should be done on a per-Sprite basis; don’t worry about optimisation because OpenGL takes care of that for you, let alone the compiler on the C++ side of things. You’ll soon realise that by breaking down this problem you can have something like

std::vector<Sprite*> sprites;

for (const auto& : i)

// etc…

for (const auto& : i)

With regards to the shaders, you shouldn’t really have them inside the Sprite class. Have a resource loader, and simply have each Sprite class retrieve the shader from that loader.

And most importantly: remember the order of transformations!

With regards to transformations of sprites, what you can do is have a glm::vec3 for sprite positions, setting the z-component to 0. You can then move your sprite by simply having a function which wants x and y values. Feed these values into the model matrix using glm::translate(…). With regards to rotation, you use glm::rotate() and simply have functions which get rotation angles. ALWAYS ROTATE ON THE Z-PANE thus it should be similar to this:

modelMatrix = glm::rotate(modelMatrix, glm::radians(angle), glm::vec3(0.f, 0.f, 1.f));

As for scaling, again a suitable setScale() function that accepts two values for x and y. Set the z component to 1 to prevent the Sprite from being scaled in z. Feed the values into glm::scale like so:

modelMatrix = glm::scale(modelMatrix, glm::vec3(scale));

Remember, that storing matrices provides little benefit because they’re just numbers; they don’t indicate what you really want to do with them. It’s better for a Sprite class to encapsulate a matrix so that it’s clear what they stand for.