Spaces, Vectors and Coordinates

1// Vec2.h
2#pragma once
3
4struct Vec2 {
5  float x;
6  float y;
7};

This simple struct allows us to store both the x and y components of a vector in a single object. To use our Vec2 type, we can create instances and access their components using the dot operator (.):

1// main.cpp
2#include <iostream>
3#include "Vec2.h"
4
5int main() {
6  // Create a vector to represent position (3,4)
7  Vec2 A{3.0, 4.0};
8  
9  // Access and display the components
10  std::cout << "Ax = " << A.x
11    << ", Ay = " << A.y;
12  
13  // We can also modify components individually
14  A.x = 5.0;
15  std::cout << "\nNew Ax = " << A.x;
16}

1Ax = 3.0, Ay = 4.0
2New Ax = 5.0

As we progress, we'll extend this Vec2 struct with additional functionality to perform vector operations like addition, subtraction, scaling, and calculating distances.

Transformations

When we’re defining a space, we are free to use any coordinate system we want, and we can position the origin in any location. The coordinate system we introduced above is a common convention and is likely to be familiar. We should note that it has the following characteristics:

• The $x$ axis is horizontal and increasing $x$ values corresponds to moving points right
• The $y$ axis is vertical and increasing $y$ values corresponds to moving points up
• The origin is usually visualized as being in the "center" of the space. We can have a point to the left or the origin by using a negative $x$ component, or below the origin by using a negative $y$ component.

But these characteristics are not true of every space. For example, we’ve already seen how SDL typically uses a different system when we’re working with windows and surfaces. It also uses the convention of $x$ being the horizontal axis and $y$ being vertical, but has two main differences:

• Increasing $y$ values correspond to moving points down
• The origin is visualized as being at the top-left of the space. As such, components are rarely negative.

The following diagram visualizes the space typically used by SDL:

In complex projects, we will typically be dealing with many spaces, each one defined differently. Much of computer graphics involves taking a set of points that are defined in one space and figuring out how they should be defined within some other space.

That other space may have a different origin, different coordinate system, and maybe even a different number of dimensions.

These calculations between spaces are typically referred to as transformations. The following steps outline just some of the main transformations involved in rendering content:

1. Local Space: For example, a 3D model is created by an artist working in a content creation tool. It is created in isolation, so the points of the model (vertices) are positioned in a space where the origin may simply be the center of the model.
2. World Space: The model is loaded into a level. The vertices of that model now need to be transformed to reflect where that model was positioned within the larger 3D world. At a minimum, the world will have a different origin, but the model may also have been rotated and scaled up or down within our level.
3. View Space: The world is viewed from a certain perspective, like a virtual camera. This might be based on where the player’s character is within the world, and the direction they are facing. All of our vertices now need to be transformed into this space so they appear in the correct position with respect to the virtual camera’s location and rotation.
4. Screen Space: The player is viewing this world through their monitor - a two-dimensional grid with its own coordinate system. The points from the view space need to be transformed so objects appear on the correct pixels on the player’s screen.

A typical video game scene can have millions of vectors that need to be processed through this transformation pipeline every frame. This is only possible to do in real-time because of our systems’ graphics processing units. GPUs are dedicated pieces of hardware designed to perform these specific types of calculations as efficiently as possible.

Summary

In this lesson, we've explored the fundamental mathematical concepts that underpin computer graphics and game development. We've learned how to define spaces using coordinate systems, represent positions as vectors, and understand the various transformations applied when rendering a scene.

These concepts form the foundation upon which we'll build more complex game systems in future lessons. Key takeaways:

• Spaces are mathematical constructs that contain objects with defined structures and rules
• Coordinate systems like the Cartesian system allow us to define positions within a space
• Vectors are ordered lists of numbers that represent positions or other values with magnitude and direction
• In C++, we can implement vectors using custom structs with component members
• Different spaces may use different coordinate systems and origins
• Transformations convert positions between different coordinate systems
• Graphics rendering involves multiple transformations from local space to screen space