Gllookat Directo Al Cuaternion

[tamat]

 Tengo una clase que contiene  una camara, dicha camara tiene posicion y rotación siendo la rotación un cuaternion.

Me gustaría saber la forma de hacer una función similar a glLookAt pero que en lugar de guardarlo en la matrix de openGL lo haga en la camara.
No me vale lo de usar glLookAt y despues extraer la matrix de modelview, busco algo que no requiera usar API de OGL.

Para los que no sepan que hace glLookAt se trata de una función que le das el centro de la camara, hacia donde tiene que enfocar y el vector arriba y te genera ya la modelview para una camara posicionada en ese lugar y enfocando al punto dado.

Mediante los cuaterniones puedo efectuar las rotaciones que hagan falta así que si alguien sabe la idea basica que me lo diga.

Hasta el momento tengo mas o menos algunos pasos como sacar los angulos con los ejes y despues aplicar varias rotaciones pero creo que hay maneras más optimas de hacerlo.

Gracias.

[BeRSeRKeR]

 Este es el código de la función gluLookAt:

Código [Seleccionar] Expand


void GLAPIENTRY
gluLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez,
  GLdouble centerx, GLdouble centery, GLdouble centerz,
  GLdouble upx, GLdouble upy, GLdouble upz)
{
  GLdouble m[16];
  GLdouble x[3], y[3], z[3];
  GLdouble mag;

  /* Make rotation matrix */

  /* Z vector */
  z[0] = eyex - centerx;
  z[1] = eyey - centery;
  z[2] = eyez - centerz;
  mag = sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]);
  if (mag) {   /* mpichler, 19950515 */
     z[0] /= mag;
     z[1] /= mag;
     z[2] /= mag;
  }

  /* Y vector */
  y[0] = upx;
  y[1] = upy;
  y[2] = upz;

  /* X vector = Y cross Z */
  x[0] = y[1] * z[2] - y[2] * z[1];
  x[1] = -y[0] * z[2] + y[2] * z[0];
  x[2] = y[0] * z[1] - y[1] * z[0];

  /* Recompute Y = Z cross X */
  y[0] = z[1] * x[2] - z[2] * x[1];
  y[1] = -z[0] * x[2] + z[2] * x[0];
  y[2] = z[0] * x[1] - z[1] * x[0];

  /* mpichler, 19950515 */
  /* cross product gives area of parallelogram, which is < 1.0 for
   * non-perpendicular unit-length vectors; so normalize x, y here
   */

  mag = sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
  if (mag) {
     x[0] /= mag;
     x[1] /= mag;
     x[2] /= mag;
  }

  mag = sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]);
  if (mag) {
     y[0] /= mag;
     y[1] /= mag;
     y[2] /= mag;
  }

#define M(row,col)  m[col*4+row]
  M(0, 0) = x[0];
  M(0, 1) = x[1];
  M(0, 2) = x[2];
  M(0, 3) = 0.0;
  M(1, 0) = y[0];
  M(1, 1) = y[1];
  M(1, 2) = y[2];
  M(1, 3) = 0.0;
  M(2, 0) = z[0];
  M(2, 1) = z[1];
  M(2, 2) = z[2];
  M(2, 3) = 0.0;
  M(3, 0) = 0.0;
  M(3, 1) = 0.0;
  M(3, 2) = 0.0;
  M(3, 3) = 1.0;
#undef M
  glMultMatrixd(m);

  /* Translate Eye to Origin */
  glTranslated(-eyex, -eyey, -eyez);

}

Saludos.

[tamat]

 Si el codigo de glLookAt ya lo tengo,  yo busco la manera de adaptarlo a cuaterniones sin usar matrices de euler, así me ahorro un paso.

Gracias de todos modos.