---

gl_matrix.cpp

//FILE:     gl_matrix.cpp
//AUTHOR:   Andrew Van Pernis <arakel@vr.clemson.edu>

#include <math.h>
#include "gl_matrix.h"

//Method definitions for gl_matrix class

void gl::matrix4::build_frustum(const GLfloat left, const GLfloat right, const GLfloat bottom, 
                                const GLfloat top, const GLfloat near, const GLfloat far){
  
  //See OpenGL Programming Guid pg. 674
  GLfloat r_minus_l = right - left;
  GLfloat t_minus_b = top - bottom;
  GLfloat f_minus_n = far - near;
  GLfloat two_x_near = 2.0*near;

  //Column 1 of 4x4 frustum matrix
  m_data[0][0] = two_x_near/r_minus_l;
  m_data[1][0] = 0.0;
  m_data[2][0] = 0.0;
  m_data[3][0] = 0.0;

  //Column 2 of 4x4 frustum matrix
  m_data[0][1] = 0.0;
  m_data[1][1] = two_x_near/t_minus_b;
  m_data[2][1] = 0.0;
  m_data[3][1] = 0.0;
  
  //Column 3 of 4x4 frustum matrix
  m_data[0][2] = (right+left)/r_minus_l;
  m_data[1][2] = (top+bottom)/t_minus_b;
  m_data[2][2] = -(far+near)/f_minus_n;
  m_data[3][2] = -1.0;

  //Column 4 of 4x4 frustum matrix
  m_data[0][3] = 0.0;
  m_data[1][3] = 0.0;
  m_data[2][3] = (-two_x_near*far)/f_minus_n;
  m_data[3][3] = 0.0;
}

/*===========================================================================*/
  
void gl::matrix4::build_perspective(const GLfloat field_of_view, const GLfloat aspect_ratio, 
                                    const GLfloat near, const GLfloat far){
  GLfloat x_min, x_max, y_min, y_max;
  y_max = near * tan(field_of_view*M_PI/360.0);
  y_min = -y_max;
  x_min = y_min*aspect_ratio;
  x_max = y_max*aspect_ratio;
  build_frustum(x_min, x_max, y_min, y_max, near, far);
}

/*===========================================================================*/

void gl::matrix4::build_look_at(const math::vector3 eye, const math::vector3 center, const math::vector3 up){
  math::vector3 X, Y, Z;
  
  //Compute a rotation matrix
  //Z vector 
  Z = eye - center;
  Z.normalize();
  
  //X vector = up cross Z
  X = math::cross(up, Z);
  X.normalize();
  
  //Y vector = Z cross X
  Y = math::cross(Z, X);
  Y.normalize();

  //Column 1 of 4x4 view matrix
  m_data[0][0] = X.x();
  m_data[1][0] = Y.x();
  m_data[2][0] = Z.x();
  m_data[3][0] = 0.0;
  
  //Column 2 of 4x4 view matrix
  m_data[0][1] = X.y();
  m_data[1][1] = Y.y();
  m_data[2][1] = Z.y();
  m_data[3][1] = 0.0;
  
  //Column 3 of 4x4 view matrix
  m_data[0][2] = X.z();
  m_data[1][2] = Y.z();
  m_data[2][2] = Z.z();
  m_data[3][2] = 0.0;
  
  //Column 4 of 4x4 view matrix
  m_data[0][3] = -1.0*math::dot(X, eye);
  m_data[1][3] = -1.0*math::dot(Y, eye);
  m_data[2][3] = -1.0*math::dot(Z, eye);
  m_data[3][3] = 1.0;
}

/*===========================================================================*/

gl::matrix4& gl::matrix4::operator= (const math::matrix4 &m){
  int i, j;
  for (i=0; i<4; i++)
    for (j=0; j<4; j++)
      m_data[i][j] = m(i,j);
  return *this;
}

/*===========================================================================*/

gl::matrix4::operator const GLfloat*(void){
  int i,j;
  for (i=0; i<4; i++)
    for (j=0; j<4; j++)
      m_transposed_data[i][j] = m_data[j][i];
  return (const GLfloat*)(m_transposed_data);
}

---