Modeling and the Transformation Pipeline

• Homogeneous Coordinates
  • We are used to the world of Cartesian coordinates (x,y,z).
  • To simplify protective geometry most graphics systems use homogeneous coordinates
  • For our purposes, it is easiest to think of homogeneous coordinates as Cartesian coordinates with a 1 appended (x,y,z,1).
  • In general, the coordinates are (xw, yw, zw, w) w≠ 0.
  • In part of the transformation process, the coordinates are divided by w, projecting from homogeneous coordinates to Cartesian coordinates.
  • By default, w is set to 1 if it is not specified.
  • And it is probably best to keep it so, unless you have a reason to change it.
• There are a number of different spaces we think of when producing graphics scenes.
• Model Space or Object Space.
  • This is where vertex data is created.
  • Each object is modeled in its own coordinate system.
  • And the object has its own unique scale.
• Word Coordinates
  • When we assemble the models into a scene
  • We usually don't want everything at the origin
  • We generally need to translate, rotate and scale objects to their proper position.
  • We usually perform lighting and possibly physics in this space as well.
• Viewing Coordinates
  • Frequently referred to as eye or camera coordinates.
  • This is where the viewer "stands" and looks at the scene.
• Clip and Normalized Device Space
  • Objects are transformed to clip space for clipping
  • And then normalized by dividing through by w.
  • Normalized space is (-1,-1,0) to (1,1,1) and is the region that is visible to the viewer.
• Finally objects are transformed from NDC to device coordinates.
• This is not exactly the modern OpenGL system, but we will discuss that later.
• Movement from each coordinate system is performed by a matrix vector multiply.
• From here on out, consider a point to be a vector [x,y,z,1]^-1 (because I don't want to take up the space in html )
• Why homogeneous coordinates?
  • Our author takes us through a long process to get here, but what is the effect of the following matrix vector multiply

    
    	| 1  0  0  tx |   | x |   | x + tx |
    	| 0  1  0  ty | × | y | = | y + ty |
    	| 0  0  1  tz |   | z |   | z + tz |
    	| 0  0  0  1  |   | 1 |   |   1   |
    	

  • This is the translation matrix.
  • glTranslatef( t_x, t_y, t_z) multiplies the current transformation matrix by the matrix above.
  • With this matrix, translations in 3-space can be accomplished with just a vector matrix multiply.
  • GPS, and other graphics hardware, are VERY good at vector matrix multiplies.
• Scaling

        | sx 0 0 0 |
        | 0 sy 0 0 |
        | 0 0 sz 0 |
        | 0 0 0 1 |
        

  • Multiply this by the point [x,y,z,1]^-1
• The order of transformation is important
  • look at scaleTranslate.C
    • This is mostly recycled code, but lets us control the order of a scale and a translate.
  • It turns out that we can concatenate transformations simply by multiplying the transformation matrices
    • Try S·T · [x,y,z,1]^-1
    • Try T·S · [x,y,z,1]^-1
  • But you know that A ·B ≠ B · A for matrices.
  • Or matrix multiplication is not commutative.
  • So

  • glTransform1() => M1
    glTransform2() => M2
    glTransform3() => M3
    
    M1(M2(M3(p))) => (M1×M2×M3)×p
           

• The last fact is important,
  • We can maintain a single (or four or five single) matrices
  • Which preserve the transformation order for objects.
  • We don't need to maintain all of the many transformations
  • And we don't need to PERFORM all of the vector matrix multiplies.
• Rotation
  • Rotate by theta about the x axis.

  •            | 1   0       0     0 | 
        R(Θ) = | 0  cos(Θ)  sin(Θ) 0 |
               | 0 -sin(Θ)  cos(Θ) 0 |
               | 0   0       0     1 | 
    	 

  • There are similar matrices for about y and z.
  • And a more complex but still derivable matrix for rotate about an arbitrary axis.
    • Translate the line so that it is through the origin
      • In openGL this is not necessary, as this is part of the definition.
      • But translate by (-x, -y,-z) if the line passes through (x,y,z)
    • Rotate the line about the y axis by Α into the xy plane
      • This amount can be found by projecting a point into the plane and computing the angle.
    • Rotate the line about the z axis by Β to align the line with the x axis
    • Rotate about the x axis by Θ
    • Rotate about the z axis by -Β
    • Rotate about the y axis by -Α
    • Translate by (x,y,z)