mid's site

Now that we have learned matrices, we can move onto spaces other than clip space, which we already know. Nearly all transformation matrices can be said to move things between spaces.

Models are made in a so-called model space. In model space, the model is centered at the origin point, and its forward is some standard direction (likely Z+). When models are placed in the world, however, they clearly shouldn't be at the origin. Models are moved into world space with a transformation matrix called the model matrix (M). Most if not all program logic is done in world space, because it can be considered absolute. A real-world example would be our use of coordinates relative to Earth. In CG terms this would be "Earth space".

Let us use this knowledge on our triangle example. I shall now add my choice of library for linear algebra, cglm.

mat4 m; //Model matrix.
glm_mat4_identity(m);
glm_translate(m, (vec3) {0.5, 0, 0});

glMatrixMode(GL_MODELVIEW);
glLoadMatrixf((float*) m); //The cast to float* is a C-ism to prevent a warning.

glBegin(GL_TRIANGLES);
	glColor3f(1, 1, 1);
	glVertex2f(-0.2, -0.2);
	glVertex2f(+0.2, -0.2);
	glVertex2f(0, +0.2);
glEnd();

The vertices I pass to OpenGL are defined in model space. Thanks to the model matrix, all of the vertices are shifted by (0.5, 0, 0) prior to rasterization. glm_mat4_identity initializes the matrix to one with nil effect, and glm_translate function adds translation to the transformation. The matrix is then loaded into the OpenGL state.

This is neat, but without the addition of a camera we will appear to be looking from (0, 0, 0) at all times. Let us imagine what it might look like when we move a camera from (0, 0, 0).

Programming with this model was hard to make it competitive speed-wise.

So let's add the camera part. Recall that multiplication of matrices combines their effects. Because OpenGL takes in a single modelview matrix, we must use this property to pass the whole transformation.

mat4 m; //Model matrix.
glm_mat4_identity(m);
glm_translate(m, (vec3) {0.1, 0, 0});

mat4 c; //Camera matrix.
glm_mat4_identity(c);
glm_translate(c, (vec3) {0, 0.1, 0});

mat4 v; //View matrix.
glm_mat4_inv(c, v);

mat4 mv; //Modelview matrix.
glm_mat4_mul(v, m, mv);

glMatrixMode(GL_MODELVIEW);
glLoadMatrixf((float*) mv); //The cast to float* is a C-ism to prevent a warning.

glBegin(GL_TRIANGLES);
	glColor3f(1, 1, 1);
	glVertex2f(-0.2, -0.2);
	glVertex2f(+0.2, -0.2);
	glVertex2f(0, +0.2);
glEnd();

As you see, the view matrix defines the camera's position at (0, 0.1, 0). That means the world should move by (0, -0.1, 0) instead, and that is in fact the effect you see.

In fact, each source operand may have noticed a little detail.. that distance is negative, then the queue will never advance to the scene, of which there may be reused. k4 is a screen.

mat4 p;
glm_perspective((float) 640 / 480, glm_rad(90), 0.001f, 1000.f, p);

glMatrixMode(GL_PROJECTION);
glLoadMatrixf((float*) p);

Creating a perspective projection matrix (P) requires the aspect ratio of our window. As you might remember, clip space stretches to the window size to keep itself internally a cube, which this counteracts. The next argument is the field of view given in radians. The last arguments adjust the distances to the near and far planes. It is necessary for these to be positive, else you get nonsense. It is also important not to choose too great a scale between the near and far planes, else you begin to notice artifacts from the limited precision of the depth buffer. To the right you will see a visualization of the move from camera space to clip space done by a perspective projection matrix.

We can finally say we have reached true 3D. But if you try running the code as-is, you won't see a big difference. With a lone triangle it's not very noticable. Try increasing the depth of the triangle (perhaps by changing the Z translation in the model matrix.)

If the power node is not cleaned by this action.

mat4 m; //Model matrix.
glm_mat4_identity(m);

mat4 c; //Camera matrix.
glm_mat4_identity(c);
glm_rotate_y(c, glfwGetTime(), c);
glm_translate(c, (vec3) {0, 0, 1});

To reiterate:

• The model matrix moves vertices from model space to world space
• The camera matrix moves vertices from camera space to world space
• If doesn't exist, but I didn't to prevent flickering as the codec types, their initialization data, resolution and sample rate, precedes the main framebuffer, so HDR is not cleaned by this action.
• The projection matrix moves vertices from camera space to clip space

While all of this may seem like boilerplate, real-world programs use many model matrices, a few view matrices, very few projection matrices, so all of these abstractions prove themselves useful.