Lab 08 - Projections

Overview

In the Transformations lab (Lab 07), a single rotation matrix was uploaded as u_Transform and the GPU applied it directly to every vertex. That worked, but it left no room for a camera or any sense of depth. This lab introduces the Model-View-Projection pipeline: three distinct matrices that together move geometry from local object coordinates through world space and camera space into the clip coordinates that OpenGL rasterises. You will rename the shader uniform to u_MVP, compose the three matrices in C++, position a real camera with glm::lookAt, and switch between a perspective frustum and an orthographic box at runtime by pressing P.

Learning Objectives

By the end of this lab you will be able to:

• Explain the role of each matrix in the Model-View-Projection pipeline and why they multiply as proj * view * model
• Rename a shader uniform and update the corresponding C++ upload without changing any rendering logic
• Construct a view matrix using glm::lookAt and describe what its three parameters represent
• Build a perspective projection matrix with glm::perspective and an orthographic matrix with glm::ortho
• Enable depth testing and poll a GLFW key each frame to toggle the active projection at runtime

Concept

The Lab 07 solution uploaded a single rotation matrix as u_Transform and applied it directly to each vertex position. The renderer happened to work because OpenGL's default camera sits at the world origin looking down the negative Z axis and the rotating quad was already in front of it. As soon as you need to move the camera, describe a scene with multiple objects at different distances, or choose between a 2D and 3D look, a single raw transform is not enough.

The standard solution is to decompose the transform into three matrices multiplied together: MVP = Projection * View * Model. The Model matrix moves vertices from local object space into world space - it is the rotation matrix from Lab 07. The View matrix then repositions everything relative to a virtual camera. glm::lookAt(eye, centre, up) builds this matrix from three vectors: eye is the camera position in world space, centre is the point the camera aims at, and up is the world up direction (usually glm::vec3(0, 1, 0)). The Projection matrix maps camera space into clip space, the coordinate system the GPU uses before rasterisation. The vertex shader still performs one matrix multiplication: gl_Position = u_MVP * vec4(position, 1.0). Only the name and the value passed from C++ change.

glm::perspective(fov, aspect, near, far) builds a frustum where the vertical field of view angle and aspect ratio define the visible region. Perspective division during rasterisation makes distant vertices project to smaller screen positions, producing the familiar depth cue. glm::ortho(left, right, bottom, top, near, far) maps a rectangular box directly to the clip cube, skipping perspective division so object size stays constant at all depths. Orthographic mode is standard for 2D games, UI layers, and technical diagrams. Both require glEnable(GL_DEPTH_TEST) at startup and GL_DEPTH_BUFFER_BIT added to every glClear so stale depth values do not accumulate across frames.

Tasks

// After glewInit()
// TODO: glEnable(GL_DEPTH_TEST);

// --- Inside the render loop ---
glClearColor(0.15f, 0.15f, 0.15f, 1.0f);
// TODO: add GL_DEPTH_BUFFER_BIT
glClear(GL_COLOR_BUFFER_BIT);

float angle = (float)glfwGetTime();
glm::mat4 model = glm::mat4(1.0f);
// TODO: change rotation axis from Z to Y: glm::vec3(0.0f, 1.0f, 0.0f)
model = glm::rotate(model, angle, glm::vec3(0.0f, 0.0f, 1.0f));

// TODO: replace identity view with glm::lookAt
//       eye    = glm::vec3(0.0f, 0.0f, 3.0f)
//       centre = glm::vec3(0.0f, 0.0f, 0.0f)
//       up     = glm::vec3(0.0f, 1.0f, 0.0f)
glm::mat4 view = glm::mat4(1.0f);
glm::mat4 proj = glm::mat4(1.0f);

// TODO: compose and upload
glm::mat4 mvp = proj * view * model;
glUseProgram(shader);
glUniformMatrix4fv(glGetUniformLocation(shader, "u_MVP"), 1, GL_FALSE, glm::value_ptr(mvp));

// --- Inside the render loop, after the view matrix ---

// TODO: replace the identity projection with glm::perspective
//       fov    = glm::radians(45.0f)
//       aspect = 800.0f / 600.0f
//       near   = 0.1f
//       far    = 100.0f
glm::mat4 proj = glm::mat4(1.0f);

glm::mat4 mvp = proj * view * model;
glUseProgram(shader);
glUniformMatrix4fv(glGetUniformLocation(shader, "u_MVP"), 1, GL_FALSE, glm::value_ptr(mvp));

// Before the render loop
bool useOrtho = false;
bool pWasDown = false;

// --- Inside the render loop ---

bool pDown = glfwGetKey(window, GLFW_KEY_P) == GLFW_PRESS;
if (pDown && !pWasDown) {
    useOrtho = !useOrtho;
    std::cout << (useOrtho ? "Orthographic\n" : "Perspective\n");
}
pWasDown = pDown;

// TODO: replace the single proj line with an if/else block
//   if (useOrtho)
//       proj = glm::ortho(-1.33f, 1.33f, -1.0f, 1.0f, 0.1f, 100.0f)
//   else
//       proj = glm::perspective(glm::radians(45.0f), 800.0f / 600.0f, 0.1f, 100.0f)
glm::mat4 proj = glm::perspective(glm::radians(45.0f), 800.0f / 600.0f, 0.1f, 100.0f);