OpenGL introduction third lesson — matrix transformation and coordinate system

matrix

A matrix is a rectangular array of mathematical expressions in which each Element is called an Element. Here is an example of a 2×3 matrix:

Matrices can be indexed by (I, j), where I is the row and j is the column, and that’s why the matrix above is called a 2 by 3 matrix.

Matrix addition and subtraction

The addition and subtraction between matrices and scalars are defined as follows:

The subtraction of matrices and scalars is also similar:

Addition and subtraction between matrices is the addition and subtraction of the corresponding elements of two matrices, so the general rule is similar to scalar operation, except that the operation can only be performed on the elements under the same index. This means that addition and subtraction are only defined for matrices of the same dimension. A 3 by 2 matrix and a 2 by 3 matrix (or a 3 by 3 matrix and a 4 by 4 matrix) cannot be added or subtracted. Let’s see how two 2 by 2 matrices add:

The same principle applies to subtraction:

The scalar times the matrix

Like adding and subtracting matrices and scalars, multiplication between matrices and scalars is the multiplication of each element of the matrix by that scalar. The following example shows the multiplication process:

Matrix multiplication

Multiplication between matrices is not necessarily complicated, but it is hard to get used to. Matrix multiplication basically means multiplying according to prescribed rules. Of course, there are some limitations to multiplying:

• Two matrices can be multiplied only if the number of columns on the left is equal to the number of rows on the right;
• Matrix multiplication does not follow Commutative, that is⋅ ⋅ B indicates B A;

Let’s take a look at an example of multiplying two 2-by-2 matrices:

And as you can see, matrix multiplication is very cumbersome and error-prone, but it doesn’t matter if it’s not enough, and we don’t want you to do it yourself in OpenGL, we have an API to do it, but I just want you to get a sense of how matrix multiplication works.

Matrix times vector

Now we know a lot about vectors. In OpenGL you can use vectors to represent positions, colors, and even texture coordinates. By analogy with a matrix, it’s just an N by 1 matrix, where N is the number of components of a vector (also called n-dimensional vectors). If you think about it, a vector is a sequence of numbers just like a matrix, but it has only one column. So how does this new definition help us? If we have an M by N matrix, we can multiply this matrix times our N by 1 vector, because the number of columns in this matrix is equal to the number of rows in this vector, so they can multiply.

But why do we care whether a matrix can be multiplied by a vector? Well, it just so happens that a lot of interesting 2D/3D transformations can be put into a matrix, and multiplying that matrix by our vector will Transform this vector. If you’re still a little confused, let’s look at some examples and you’ll get the point in no time.

Unit matrix

In OpenGL, we usually use a 4 by 4 transformation matrix for a couple of reasons, and one of the most important reasons is that most vectors have four components. The simplest transformation Matrix we can think of is the Identity Matrix. The identity matrix is an N by N matrix that is zero except for one for the left-hand corner line. As can be seen in the following, this transformation matrix leaves a vector completely unchanged:

You might wonder what’s the use of an untransformed transformation matrix? The identity matrix is usually the starting point for generating other transformation matrices, and if we dig into linear algebra, it’s also a very useful matrix for proving theorems and solving linear equations.

The zoom

A transformation matrix will be constructed to provide us with scaling. We know from the identity matrix that each diagonal entry is individually multiplied by the corresponding entry of the vector. What happens if we change 1 to 3? So in this case, we’re multiplying each member of the vector by 3, and we’re actually scaling the vector by 3. If we express the scaling variables as (S1,S2,S3) we can define a scaling matrix for any vector (x,y,z) :

Note that the fourth scaling vector is still 1, because scaling the W component in 3D space is meaningless. The W component has other uses.

The displacement

Displacement (Translation) is the process of adding another vector on the basis of the original vector to obtain a new vector in a different position, thus moving the original vector on the basis of the displacement vector. We’ve already talked about vector addition, so this shouldn’t be too unfamiliar. As with the scaling matrix, there are several special positions on the 4-by-4 matrix to perform specific operations, and for displacement they are the top three values in the fourth column. If we express the displacement vector as (Tx,Ty,Tz), we can define the displacement matrix as:

The displacement matrix, which allows us to move objects in three directions (x, y, and Z), is a very useful transformation matrix in our transformation toolbox.

rotating

To rotate in 3D space you need to define an Angle and a Rotation Axis. The object will rotate at a certain Angle along a given axis of rotation. When a 2D vector rotates in 3D space, we set the rotation axis to the Z axis.

Using trigonometry, you can transform a vector into a rotated vector given an Angle. This is usually achieved using a series of sines and cosines (commonly referred to as sines and cosines) in various clever combinations.

The rotation matrix is defined differently for each unit axis in 3D space, and the rotation Angle is denoted by θ :

Rotation along the X-axis:

Rotation along the y axis:

Rotation along the Z axis:

Using the rotation matrix we can rotate any position vector along an axis of unit rotation. You can also compose multiple matrices, for example, by first rotating along the X-axis and then rotating along the Y-axis.

You don’t have to worry too much about how rotations look complicated, how these rotations are computed, except to understand that rotations are also done by multiplying a particular matrix.

Combination of matrices

The real power of using matrices for transformations is that we can combine multiple transformations into one matrix based on the multiplication of matrices. Let’s see if we can generate a transformation matrix that combines multiple transformations. Suppose we have a vertex (x, y, z) and we want to scale it by a factor of 2 and then shift it by (1, 2, 3) units. We need a displacement and scaling matrix to do these transformations. The resulting transformation matrix looks like this:

Notice, when we multiply matrices we write the displacement first and then the scaling. Matrix multiplication is not commutative, which means that their order matters. When matrices are multiplied, the matrix on the far right is the first one to multiply vectors, so you should read the multiplication from right to left. It is recommended that when you combine matrices, scale first, then rotate, and finally shift, otherwise they affect each other (negatively). For example, if you move and then scale, the displacement vector will also be scaled!

Multiplying our vector by our final transformation matrix gives the following result:

Good job! The vector is scaled by 2, and then shifted by 1, 2, 3.

Coordinate systems in OpenGL

After the vertices are colored in OpenGL, our visible vertices are Normailzed Device Coordinate (NDC). So x,y, and z at each vertex should be direct from -1 to 1, otherwise they’re invisible to us.

A vertex passes through several important coordinates before being converted to a fragment:

int main(int argc, char* argv[]){   
 gltSetWorkingDirectory(argv[0]);   
 glutInit(&argc, argv);   
 glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_SINGLE);   
 glutInitWindowSize(800, 600);   
 glutCreateWindow("Matrix transformation Demo");   
 glutReshapeFunc(ChangeSize);   
 glutDisplayFunc(RenderScene);   
 GLenum error = glewInit();    
 if(GLEW_OK ! = error) { fprintf(stderr,"GLEW Error: %s\n",glewGetErrorString(error));      
   return 1;  
  }   
 setupRC();   
 glutMainLoop();   
 return 0;
}Copy the code

There are three methods that are important. The first is setupRC, which does some preparatory work before drawing:

void setupRC() {glClearColor(0.8, 0.8, 0.8, 1.0f); / / set the color screen clearing shaderManager InitializeStockShaders (); // initialize fixed pipeline glEnable(GL_DEPTH_TEST); GltMakeSphere (torusBatch, 0.4, 10, 20); // Form a ball glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // Set polygon fill mode}Copy the code