You should read the book and lecture notes on matrix manipulation then go through this exercise.

The transformation matrices were covered in the lecture. Generally, they are 4x4 matrices that repersent the transformations (translations, scaling or rotations). The transformation matrix is multiplied by the co-ordinates of the vertices of the objects in the scene to achieve the transformation.

The lecture notes detail the construction of the transormation matrices and the homogenous co-ordinate that makes them 4x4. If you have any questions about this, please ask.

This exercise is aimed at getting you used to the effects of transformations and how they are achieved within OpenGL

• One possible way to describe the position of the triangles would be to hard code the vertices of each triangle. However, for a complicated model the time to do this would be prohibitive.
• We can write a function that draws a triangle at the origin and then apply some transformations and redraw it at different points in the scene, with different colours.
• The intial triangle is defined as:

  
  	 
  	 //red triangle in upper right
  	 
      glBegin(GL_POLYGON);
        glColor3f( red, green, blue );
        glVertex3f(0.0, 0.0, 0.0);
        glVertex3f(0.0, 1.0, 0.0);
        glVertex3f(1.5, 1.0, 0.0);
      glEnd();
      

• First we look at performing cumulative translations:
  • Draw 4 triangles or any other object in the viewport. For example:

    
    	 
    	 //red triangle in upper right
    	 //It has the same coordinate values as the basic triangle in
    	 //the above drawTriangle() function. The drawTriangle(r, g, b)
    	 //function takes the rgb values as parameters.
    	 
        drawTriangle(1, 0, 0);
    	 
    	 //green triangle in upper left
    	 //need to translate this 1.5 units 
    	 //  to the left of the red triangle
    	 
        glTranslatef(-1.5, 0.0, 0.0);
        drawTriangle(0, 1, 0);
    	 
    	 //blue triangle in lower left
    	 //need to translate this 1.5 units 
    	 //  down from the green triangle 
    	 
        glTranslatef(0.0, -1.5, 0.0);
        drawTriangle(0, 0, 1);
    	 
    	 //yellow triangle in lower right
    	 //need to translate this 1.5 units 
    	 //  right from the blue triangle 
    	 
        glTranslatef(1.5, 0.0, 0.0);
        drawTriangle(1, 1, 0);
        

  • Doing the transformations this way we always have to remember where we drew last. Each new polygon, and tranformation, is relative to the position of the last one.
  • This can be confusing when there are lots of objects in the scene.
  • Instead, we can make use of the matrix stack to make all transformations relative to the origin (or some specific point).
  • To do this we need to push and pop the matrix stack.
  • As with most stacks we can push a value onto the top of the stack temporarily and when we are finished with it we can pop the stack to get back to the original value, or position.
  • When you push another matrix onto the stack its value is a copy of the matrix before the push operation.
  • We do this with transformations, so that we can always specify the transformation from the origin and not the previous objects position.
  • We rewrite the above this way: (pay attention to the position of the glPushMatrix()/glPopMatrix() statements and the changed values of the translations (glTranslatef()).

    
    	 
    	 //load the identity matrix onto the current matrix in the
    	 //stack to ensure all transformations are relative to the origin.
    	 
        glLoadIdentity();
    	 
    	 //red triangle in upper right 
    	 // - which has it's lower vertex at the origin
    	 
        glPushMatrix();
        drawTriangle(1, 0, 0);
        glPopMatrix();
    	 
    	 //green triangle in upper left
    	 //need to translate this 1.5 units 
    	 //  to the left of the red triangle/origin
    	 
        glPushMatrix();
        glTranslatef(-1.5, 0.0, 0.0);
        drawTriangle( 0, 1, 0 );
        glPopMatrix();
    	 
    	 //blue triangle in lower left
    	 //need to translate this 1.5 units down
    	 //  and 1.5 units left of the red triangle/origin
    	 
        glPushMatrix();
        glTranslatef(-1.5, -1.5, 0.0);
        drawTriangle( 0, 0, 1 );
        glPopMatrix();
    	 
    	 //yellow triangle in lower right
    	 //need to translate this 1.5 units down
    	 // from the red triangle/origin
    	 
        glPushMatrix();
        glTranslatef(0.0, -1.5, 0.0);
        drawTriangle( 1, 1, 0 );
        glPopMatrix();
    	 
        

  • If you want to ensure you are drawing from the origin remember to include: glLoadIdentity();
    glLoadIdentity(); loads the identity matrix onto the current matrix on the matrix stack to ensure that all subsequent transformations are relative to the origin.
  • This is what happens when you leave the original translation values when you add the matrix push and pop:
    
  • Play with these values and observe the results.