Transformations

• Review matrix-matrix and matrix vector multiply
• If A, B and C are 4x4
  • Is AB=BA?
  • Is A(BC) = (AB)C
• We will take advantage of the second fact quite a bit.
• There is a section on homogeneous coordinates.
  • They allow translation in the plane
  • They allow the use of a single vector matrix multiply in the end
  • And allow OpenGL to do the last stages of the transformation pipeline.
• A little practical vectors first
  • The redbook authors provide a series of classes that are useful
  • ~dbennett/Redbook/include/vec.h
    • vec2,3,4
    • Lots of constructors which allow conversion between types.
    • overloaded insertion and extraction operators.
    • Lots of operations (*,-, ...)
    • And more +=, -= ...
    • plus
      • Dot and cross product.
      • length (as in linear)
      • Normalize (v/length(v))
• And some matrix operations
  • ~dbennett/Redbook/include/mat.h
  • mat2, 3, 4
  • The default constructor builds the identity matrix.
  • Operations (+,-, ...)
  • Plus vector matrix multiply
  • And I/O
  • Transpose (mat4 a, b; b = transpose(a);)
• Some Transformations
  • Translation

    •      |1.0  0.0  0.0   Tx|
           |0.0  1.0  0.0   Ty|
      T =  |0.0  0.0  1.0   Tz|
           |0.0  0.0  0.0  1.0|
      

    • Used to move things to the proper location.
    • From the matrix library mat4 Translate(x,y,z); constructs a translation matrix.
    • There are others (take a vec3, vec4 as parameters).
  • Scale

        | Sx  0.0  0.0  0.0|
    S = |0.0   Sy  0.0  0.0|
        |0.0  0.0   Sz  0.0|
        |0.0  0.0  0.0  1.0|
    	     

    • Scales with respect to the origin
      • All points either get further or closer to the origin.
      • The origin does not move.
    • mat4 Scale(x,y,z) and others.
  • What if we want to scale about a point, say (x,y,z);
    • T1 = Translate by (-x,-y,-z) to move that point to the origin.
    • S1= Scale
    • T2 = Translate by (x,y,z) to move that point to the origin.
    • p' = T2 S1 T1 p
    • But isn't this expensive?
    • No we can form S' = T2 S1 T1 once
    • Then do p' = S' p many times.
    • Not really any more expensive than the first.
  • Rotate
    • There are three different rotation matrices.
    • Rotate about the x, y and z axis.
    • In general, you can translate to the axis, rotate, then translate back.
    • Rotation about an arbitrary axis is somewhat complex.
• Supporting uniform matrix communications between the app and the shader
  • void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
    • Location is the value returned from a query
    • count in this case is the number of matrices to be modified.
    • transpose indicates that the matrix should be transposed.
    • The matrix is supplied as the last bit.
• In use
  • It is not uncommon to have a set of matricies active at each step of the composition pipeline.
    • a model may consist of multiple items which need to be scaled, rotated and translated into place.
    • The model it's self may need to be moved about the world.
    • The world may be rotated scaled and such.
• Demo 7 is here.