TD1 - Transformations/Visualisation 3D

1. Quelques précisions : coordonnées et transformations openGL

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();           // pas de transformation
glTranslatef(tx, ty, tz);    // translation
glRotatef(a, axe_x, axe_y, axe_z); // rotation de a degrés autour du vecteur axe_x, axe_y, axe_z

repere_tronc()
tracé_du_tronc();

glPushMatrix();         // conserver la matrice du repere global
glRotatef(40., 0,0,1);  // tranformation locale pour le bras gauche (rotation / repere du tronc)
tracé_du_bras();
glPopMatrix();          // revenir au repere global

glPushMatrix();         // conserver la matrice du repere global
glRotatef(-40., 0,0,1); // transformation locale pour le bras droit (rotation / repere du tronc)
tracé_du_bras();
glPopMatrix();          // revenir au repere global

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1.,1., -1.,1., 1.,-1.);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60., 1., 1., 100.);

• glLoadMatrix()
• glMultMatrix()
  
• glMatrixMode()
• glLoadIdentity()
• glPushMatrix()
• glPopMatrix()
• glTranslate()
• glRotate()
• glScale()

2. Décrire des objets

3. Rappels / Exercices

4. Questions Subsidiaires

5. Annexes

Thinking about Transformations

Let's start with a simple case of two transformations: a 45-degree counterclockwise rotation about the origin around the z-axis, and a translation down the x-axis. Suppose that the object you're drawing is small compared to the translation (so that you can see the effect of the translation), and that it's originally located at the origin. If you rotate the object first and then translate it, the rotated object appears on the x-axis. If you translate it down the x-axis first, however, and then rotate about the origin, the object is on the line y=x, as shown in Figure 3-4. In general, the order of transformations is critical. If you do transformation A and then transformation B, you almost always get something different than if you do them in the opposite order.

Now let's talk about the order in which you specify a series of transformations. All viewing and modeling transformations are represented as 4x4 matrices. Each successive glMultMatrix*() or transformation command multiplies a new 4x4 matrix M by the current modelview matrix C to yield CM. Finally, vertices v are multiplied by the current modelview matrix. This process means that the last transformation command called in your program is actually the first one applied to the vertices: CMv. Thus, one way of looking at it is to say that you have to specify the matrices in the reverse order. Like many other things, however, once you've gotten used to thinking about this correctly, backward will seem like forward.

Consider the following code sequence, which draws a single point using three transformations:

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMultMatrixf(N);                /* apply transformation N */
glMultMatrixf(M);                /* apply transformation M */
glMultMatrixf(L);                /* apply transformation L */
glBegin(GL_POINTS);
glVertex3f(v);                   /* draw transformed vertex v */
glEnd();

With this code, the modelview matrix successively contains I, N, NM, and finally NML, where I represents the identity matrix. The transformed vertex is NMLv. Thus, the vertex transformation is N(M(Lv)) - that is, v is multiplied first by L, the resulting Lv is multiplied by M, and the resulting MLv is multiplied by N. Notice that the transformations to vertex v effectively occur in the opposite order than they were specified. (Actually, only a single multiplication of a vertex by the modelview matrix occurs; in this example, the N, M, and L matrices are already multiplied
into a single matrix before it's applied to v.)

General-Purpose Transformation Commands

If you want to specify explicitly a particular matrix to be loaded as the current matrix, use glLoadMatrix*(). Similarly, use glMultMatrix*() to multiply the current matrix by the matrix passed in as an argument. The argument for both these commands is a vector of sixteen values (m1, m2, ... , m16) that specifies a matrix M as follows:

[...]

Caution: If you're programming in C and you declare a matrix as m[4][4], then the element m[i][j] is in the ith column and jth row of the OpenGL transformation matrix. This is the reverse of the standard C convention in which m[i][j] is in row i and column j. To avoid confusion, you should declare your matrices as m[16].

void glLoadMatrix{fd}(const TYPE *m);

Sets the sixteen values of the current matrix to those specified by

m.

void glMultMatrix{fd}(const TYPE *m);

Multiplies the matrix specified by the sixteen values pointed to by

m by the current matrix and stores the result as the current matrix.

Note: All matrix multiplication with OpenGL occurs as follows: Suppose the current matrix is C and the matrix specified with glMultMatrix*() or any of the transformation commands is M. After multiplication, the final matrix is always CM. Since matrix multiplication isn't generally commutative, the order makes a difference.