jueves, 26 de abril de 2012

Unidad 4 Iluminación y Sombreado


Relleno de Los Polígonos

Color de relleno

Para elegir el color de los polígonos, basta con hacer una llamada a glColor entre la definición de cada polígono. Modificando el código que dibujaba dos triángulos como ejemplo este codigo: 
glBegin(GL_TRIANGLES);
      glColor3f(1.0f, 0.0f, 0.0f);      
glVertex3f(0.0f,0.0f, 0.0f);      
glVertex3f(2.0f,0.0f, 0.0f);      
glVertex3f(1.0f,1.0f, 0.0f);      
 glColor3f(0.0f,1.0f, 0.0f);     
 glVertex3f(-1.0f,0.0f, 0.0f);     
 glVertex3f(-3.0f,2.0f, 0.0f);     
 glVertex3f(-2.0f,0.0f, 0.0f);glEnd(); 
Esta modificación provocará que el primer triángulo se ponga en rojo y el segundo en verde. La función glColor define el color de rellenado actual y lleva como parámetros los valores de las componentes RGB del color deseado y, opcionalmente, un cuarto parámetro con el valor alpha. Estos parámetros son flotantes y se mueven en el rango [0.0,1.0].

Modelo de sombreado

Es el método que utiliza OpenGL para rellenar de color los polígonos. Se especifica con la función glShadeModel. Si el parámetro es GL_FLAT, ogl rellenará los polígonos con el color activo en el momento que se definió el último parámetro; si es GL_SMOOTH, ogl rellenará el polígono interpolando los colores activos en la definición de cada vértice.
 Este código es un ejemplo de GL_FLAT: 
glShadeModel(GL_FLAT);glBegin(GL_TRIANGLES);         glColor3f(1.0f, 0.0f, 0.0f);  // activamos el color rojo
      glVertex3f(-1.0f, 0.0f, 0.0f);
      glColor3f(0.0f, 1.0f, 0.0f);  // activamos el color verde
      glVertex3f(1.0f, 0.0f, 0.0f);
      glColor3f(0.0f, 0.0f, 1.0f);  // activamos el color azul
      glVertex3f(0.0f, 1.0f, 0.0f);glEnd();








 El triángulo se rellena con el color azul, puesto que el modelo de sombreado es GL_FLAT y el color activo en la definición del último vértice es el azul. Sin embargo, este mismo código, cambiando la primera línea:
glShadeModel(GL_SMOOTH);
glBegin(GL_TRIANGLES);   
      glColor3f(1.0f, 0.0f, 0.0f);  // activamos el color rojo
      glVertex3f(-1.0f, 0.0f, 0.0f);
      glColor3f(0.0f,1.0f, 0.0f);  // activamos el color verde
      glVertex3f(1.0f,0.0f, 0.0f);
      glColor3f(0.0f, 0.0f, 1.0f);  // activamos el color azul
      glVertex3f(0.0f, 1.0f, 0.0f);glEnd();
produciría una salida similar a la de la Ilustración 3.8, donde se aprecia claramente la interpolación de colores.




Clasicas:

Iluminacion local.

Luces que no son extensas, como las reales, sino inextensas, puntuales. Y, por añadidura, se relacionan con los objetos como mónadas aisladas, sin tener en cuenta la interacción entre ellos. Esto explica lo artificioso de muchas de las técnicas que se describirán más adelante y que buscan compensar estas limitaciones. Las dos técnicas principales son el trazado de rayos (ray tracing) y la radiosidad (radiosity)


Renderizado en Tiempo real 

La idea fundamental del procesado en tiempo real es que todos los objetos deben ser descompuestos en polígonos. Estos polígonos serán descompuestos a su vez en triángulos. Cada triángulo será proyectado sobre la ventana bidimensional y rellenado con los colores adecuados para reflejar los efectos de la iluminación, texturas, etc. Una vez se han generado los triángulos, en la pipeline existen dos partes claramente diferenciadas: una primera etapa operaciones realizadas sobre cada uno de los vértices, y después de que éstos se proyecten sobre la ventana, entonces comienza una segunda fase de cálculos realizados para cada pixel cubierto por los triángulos.

Realistas:

Iluminación global. 

Son sencillos y rápidos pero proporcionan imágenes muy simples, que no representan adecuadamente el modo en que la luz ilumina los objetos y los espacios. Esto no quiere decir que no sean útiles para un gran número de casos, y es muy importante calibrar adecuadamente que es lo que se necesita, pues puede muy bien ocurrir que un cálculo local proporcione imágenes relativamente esquemáticas pero más adecuadas para la representación de un proyecto. 

Trazado de Rayos 

El trazado de rayos computa la interacción de la luz desde un punto de vista determinado y es particularmente adecuado para superficies reflectantes. Puede utilizarse como propiedad específica de un determinado material.




 Radiosidad 
Está basado en principios generales que se pueden encontrar en un manual general sobre rendering. En el estadio inicial la escena consta de dos tipos de objetos: objetos que emiten luz y objetos que reciben luz. A partir de aquí, en una primera vuelta, se computa la luz que recibe cada objeto o, en una aproximación más exacta, cada parte de un objeto, según una subdivisión cuya densidad puede precisarse en sucesivas aproximaciones.

Casi todos los modelos de iluminación necesitan conocer la normal de cada superficie para calcular su color. 

 El primero, llamado método de Gouraud, efectúa una interpolación a partir de los colores calculados por los vértices del polígono, en los que se conoce la normal. El segundo llamado método de Pong, interpola la normal en el punto en estudio a partir de las normales en los vértices, calculando a continuación el color con la ayuda de esta normal según el modelo de iluminación elegido .









Cálculos de iluminación por pixel

Iluminación por fragmento (por pixel) puede ser elaborada en hardware de gráficos moderno como un proceso de post-rasterización por medio de un programa de shader.
Pixel Shader (PS) como un pequeño programa que procesa fragments (algo así como pixelscon más datos) y que se ejecuta en la GPU. Al crear un PS, se crea una función de procesado de fragmentos que manipula datos de fragmentos.
Frecuentemente necesitan datos del VS, llegando incluso a veces a ser “conducidos” por éste. Por ejemplo, para calcular una iluminación por pixel, el PS necesita la orientación del triángulo, la orientación del vector de luz y en algunos casos la orientación del vector de vista.


Alto Acabado

Sombreado Constante o plano. Un cálculo para todo el polígono. Obtenemos una intensidad  que aplicamos a un conjunto de puntos de un objeto (p.ej. todo un triángulo). Aceleramos el proceso de síntesis.  Correcto si se verifica: Fuente de luz en el infinito. Observador en el infinito.

Sombreado Constante ó Plano
Un cálculo para todo el polígono
Los tres vectores, l, n y v, pueden variar según se va entre puntos sobre una superficie.
• Para un polígono plano, n es constante.
• Si se asume un observador distante, v es constante sobre el polígono.
• Si la fuente de luz es distante, l es constante.
Si los tres vectores son constantes, entonces el cálculo de sombreado se lleva a cabo una sola vez para cada polígono, y se asignará la misma sombra a cada punto en el polígono.

Modelo de Reflexión Phong 


     El modelo de reflexión de Phong es eficiente y suficientemente aproximado a la realidad física para producir buenas imágenes, bajo una variedad de condiciones de luz y propiedades de materiales. Apoya los tres tipos de interacciones material-luz: ambiente, difusa y especular. Si se tiene un conjunto de fuentes puntos, con componentes independientes para cada uno de los tres colores primarios para cada uno de los tres tipos de interacciones material-luz.


Ray Tracing 


     En muchas formas, ray tracing es una extensión al enfoque de rendering con un modelo de iluminación local. Está basado en la observación previa que, de los rayos de luz saliendo de una fuente, los únicos que contribuyen a la imagen son aquellos que entran al lente de la cámara sintética y pasan por el centro de proyección. 

Buffer de Profundidad.

     El Z-Buffer se basa en que al generar la posición de un punto en la pantalla la computadora reserve una zona de memoria especial, llamada Z-Buffer, información relacionada con la profundidad del punto que ocupa en la escena representada. Cuando el ordenador representa un nuevo punto consulta el Z-Buffer del píxel que corresponde en pantalla. Si el valor que ya existe en el píxel es mayor que el que posee el nuevo punto, el sistema asume que este último es el visible y lo sustituye en la memoria del Z- Buffer.

Buffer Stencil.

     Stencill Buffer es una memoria intermedia que analiza y actualiza píxeles (con sus operaciones) junto con “depth buffer” o buffer de profundidad. Añade planos de bits adicionales para cada píxel además de los bits de color y profundidad. 

     Stencil buffer es similar al buffer de profundidad en que los dos son colección de planos de bit que no se pueden mostrar. Del mismo modo que el buffer de profundidad asocia a cada píxel de la ventana un valor de profundidad, el stencil buffer asocia su propio valor a cada píxel mostrado.

Buffer de Acumulacion 


     Normalmente se usa un buffer de acumulación para unir las 2 imágenes 


Fuentes de Luz 


La luz puede dejar una superficie mediante dos procesos fundamentales:
  • Emisión propia 
  • Reflexión 
     Normalmente se piensa en una fuente de luz como un objeto que emite luz solo mediante fuentes de energía internas, sin embargo, una fuente de luz, como un foco, puede reflejar alguna luz incidente a esta del ambiente. Este aspecto no será tomado en cuenta en los modelos más sencillos.


Fuentes de Luz Distantes 

     La mayoría de los cálculos de sombreado requieren la dirección de un punto sobre la superficie a la fuente de luz. Según se mueve a lo largo de la superficie, se debe recomputar este vector para calcular la intensidad en cada punto, una computación que es una parte significativa del cálculo del sombreado. Sin embargo, si la fuente de luz está lejos de la superficie, el vector no cambiará mucho según se mueve de un punto a otro, al igual que la luz del sol da en todos los objetos cercanos entre si con el mismo ángulo. 


Fuentes de Color 

Para la mayoría de las aplicaciones, se puede modelar fuentes de luz en base a tres componentes primarios, RGB, y puede usar cada uno de los tres colores fuentes para obtener el componente de color correspondiente que un observador humano vería.


Luz Ambiente 

La luz ambiente ilumina por igual todas las zonas en sombra para simular el efecto de interacción entre objetos que hace que las partes en sombra de los objetos queden parcialmente iluminadas. 

En algunos cuartos, las luces se diseñan y ubican para proveer iluminación uniforme en el cuarto. Tal iluminación se logra mediante fuentes grandes con difusores cuyo propósito es esparcir la luz en todas las direcciones. Se puede crear una simulación precisa de tal iluminación, modelando todas las fuentes distribuidas, y luego integrando la iluminación de estas fuentes en cada punto de una superficie reflectora. Hacer tal modelo y generar la escena sería un tarea formidable para un sistema gráfico, especialmente si se desea ejecución en tiempo real. De manera alternativa, se puede ver el efecto deseado de las fuentes: lograr un nivel de luz uniforme en el cuarto. Esta iluminación uniforme se llama luz ambiente. Si se sigue este segundo enfoque, se puede postular una intensidad ambiente en cada punto del ambiente. Por lo tanto, iluminación ambiente se caracteriza por una intensidad Ia, que es idéntica en cada punto de la escena.

Spotlights (direccionales) 

     Los spotlights se caracterizan por un rango delgado de ángulos por los cuales se emite luz. Se puede construir un spotlight sencillo de una fuente de punto limitando los ángulos de donde la luz de la fuente se puede ver. Se puede usar un cono cuyo ápice está en ps, apuntando en la dirección ls, y cuyo ancho está determinado por el ángulo θ.

Intensidad completa 

La intensidad completa exclusivamente por efectos de iluminación es la siguiente:






miércoles, 18 de abril de 2012

Carro 2D en movimiento

#include <GL/glut.h>
GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f;


GLint ancho=900;
GLint alto=600;
 int ang =0 ;
 int movx = 0;
int hazPerspectiva = 0;
void reshape(int width, int height)
{
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    if(hazPerspectiva)
  gluPerspective(60.0f,(GLfloat)width/(GLfloat)height, 1.0f, 20.0f);
              
     else
       glOrtho(-4,4, -4, 4, 1, 10);
       glMatrixMode(GL_MODELVIEW);
    ancho = width;
    alto = height;
}
void Piso(void)
{
    glColor3f(2.0f, 1.0f, 0.0f);
 glScalef(1.5f,0.0f,1.5f);
    glBegin(GL_QUADS);       //cara abajo
    glVertex3f( 10.0f,-10.0f, -10.0f);
    glVertex3f( 10.0f,-10.0f,  10.0f);
    glVertex3f(-10.0f,-10.0f,  10.0f);
    glVertex3f(-10.0f,-10.0f, -10.0f);
    glEnd();
}
void carro(void)
{
   // glColor3f(0.0f, 0.2f, 0.0f);

    glBegin(GL_POLYGON);       //carro
    glVertex3f(-2.5f,0.5f, -2.0f);
    glVertex3f( 4.5f,0.5f, -2.0f);
    glVertex3f(3.5f,2.0f,  -2.0f);
    glVertex3f(2.0f,2.0f, -1.0f);
    glVertex3f(1.f,3.0f, -2.0f);
    glVertex3f(-0.5f,3.0f, -2.0f);
    glVertex3f(-1.5f,2.0f, -2.0f);
    glEnd();
}
void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
    glTranslatef(0.0f, 0.0f, -5.0f);
    glRotatef(15, 1.0f, 0.0f, 0.0f);
    glRotatef(15, 0.0f, 1.0f, 0.0f);
     Piso();
 
 //dibuja 2da rueda
 glLoadIdentity();

  glColor3f(1.0f, 1.0f, 1.0f);
  glTranslatef(movx,0.0,0.0);
  carro();
  glLoadIdentity();
      
  glTranslatef(-.5f,0.5f,-1.0f);
  glColor3f(0.0f, 0.0f, 0.0f);
  glRotatef(ang,1.0,0.0,0.0);
  glTranslatef(movx,0.0,0.0);
  glutSolidSphere(0.7f, 16, 16);
  glLoadIdentity();

  glTranslatef(3.0f,0.5f,-1.0f);
  glColor3f(0.0f, 0.0f, 0.0f);
  glRotatef(ang,1.0,0.0,0.0);
  glTranslatef(movx,0.0,0.0);   
      glutSolidSphere(0.5f, 16, 16);
      glLoadIdentity();
    glFlush();
    glutSwapBuffers();
}
void init()
{
    glClearColor(0,0,0,0);
    glEnable(GL_DEPTH_TEST);
    ancho = 600;
    alto = 900;
}
void idle()
{
    display();
}
void specialkeyevent( int key, int Xx, int Yy )
{   
 switch ( key ) {
  
  case GLUT_KEY_LEFT:
  movx-=1;
  ang-=1;
  display();
  break;
  case GLUT_KEY_RIGHT:
  movx+=1;
  ang-=1;
  display();
  break;  
 }
 glutPostRedisplay();
}
int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(ancho, alto);
    glutCreateWindow("Cubo 1");
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutIdleFunc(idle);
    glutSpecialFunc(specialkeyevent );
    glutMainLoop();
    return 0;




lunes, 16 de abril de 2012

Funciones para graficar circulos y eclipses

SUPERFICIES CUÁDRICAS
Una clase de objetos que se Utiliza frecuentemente es la de las superficies cuádricas, que se describen con ecuaciones de segundo grado (cuádricas). Entre ellas se incluyen las esferas, los elipsoides, los toros, los paraboloides y los hiperboloides. Las superficies cuádricas, particularmente las esferas y los elipsoides, son elementos comunes en las escenas gráficas, y las subrutinas para generar estas superficies están disponibles a menudo en los paquetes gráficos. También, las superficies cuadráticas se pueden producir con representaciones mediante splines racionales.

Esfera
En coordenadas cartesianas, una superficie esférica de radio r centrada en el origen de coordenadas se define
como el conjunto de puntos (x,y, z) que satisface la ecuación:
También podemos describir la superficie esférica de forma paramétrica, utilizando los ángulos de la lati-
lud y la longitud (Figura 8.2):
X = r eos < eos 0 ¡>-7t/2 < (¡> < Ttll

y = r e o s 0sin ft -n<Q<n

z = r sin <p
La representación paramétrica de las Ecuaciones propociona un rango simétrico para los parámetros angulares 0 y <> Como alternativa, podríamos escribir las ecuaciones paramétricas utilizando coordenadas ¡.
esféricas estándar, en las que el ángulo t¡> se especifica como eolatitud (Figura 8.3). Entonces, 0 se define den-
tro del rango 0 < 0 < n y 6 se toma a menudo en el rango 0 < 6 < 2/r. Podríamos también establecer la repre-
sentación utilizando parámetros uy v definidos sobre el rango que varía entre 0 y I, haciendo las sustituciones <f> = k u y 0 = 2k v.









Elipsoide
Una superficie elipsoidal se puede describir como una ampliación de la superficie esférica, en la que el radio en ires direcciones perpendiculares entre sí puede tener valores diferentes. La representación cartesiana de los puntos de la superficie de un elipsoide centrado en el origen es:
Una representación paramélrica de un elipsoide en función del ángulo de la latitud 0 y del ángulo de la longitud 0 d e la Figura 8.2 es:
x = r eos 0 eos ft  -7i/2 <<p<7V/2

y = t\ eos 0 sin ft - k<6<k

Z = r. Sin 0
Un objeto con forma de donut se denomina toro. Muy a menudo se describe como la superficie generada al hacer girar un círculo o una elipse alrededor de un eje coplanario que es externo a la cónica.






SUPERCUÁDRICAS


Superelipse
Obtenemos la representación cartesiana de una superelipse a partir de la ecuación de una elipse permitiendo que el exponente de los términos ¿rey sea variable. Un modo de hacer esto es escribir la ecuación cartesiana de la superelipse en la forma: \2/s+V


Superelipsoide
Una representación cartesiana de un superelipsoide se obtiene a partir de la ecuación de un elipsoide incorporando dos parámetros exponenciales:

2/íj/f>\ 2/1,= 1I

Con í| = s = 1. tenemos un elipsoide ordinario. Podemos a continuación escribir la representación parametrica correspondiente al superelipsoide de la
Ecuación.

x = r eos' 0 c o s  -nI2<<t><7tt2

y = ñ e o s ' &úx\ 0,  -K <0 <K

 FUNCIONES OpenGL PARA SUPERFICIES CUÁDRICAS Y SUPERFICIES
CÚBICAS


 Funciones para superficies cuádricas de GLUT
(¡eneramos una esfera con GLUT con cualquiera de las dos funciones siguientes:
glutWireSphere (r, nLongitudes, nLatitudes}¡

O

glutSolidSphere (r, nLongitudes, nLatitudes);


 Un cono con GLUT se obtiene con:

glutWireCone (rBase, height, nLongitudes, nLatitudes);

o

glutSolidCone (rBase, height, nLongitudes, nLatitudes);


 Las visualizaciones alámbricas o con superficie sombreada de un toro con sección recta circular se generan mediante:

glutWireTorus (rCrossSection, rAxial, nConcentrics, nRadialSlicesí;

o

glutSolidTorus (rCrossSection, rAxial, nConcentrics, nRadialSlices);


 Función de GLUT para la generación de una tetera con una superficie cúbica

 Podemos visualizar la tetera, como una malla de cerca de mil parches de superficies bicúbicas, utíliIizando cualquira de las dos funciones siguientes de GLUT:
glutWireTeapot (size);

0

glutSolidTeapot (size);

 Funciones para la generación de superficies cuádricas de GLU

 GLUquadricObj  *spherel;

 Spherel= gluNewQuadric( ) ;


gluQuadricDrawStyle (spherea, GLD_LINE};

gluSphere  (spherel, v, nLongitudes, nLatitudes);

 Para producir una vista de un cono, un cilindro, o cilindro con tapas, reemplazamos la función g l u S p h e r e por

gluCylinder (quadricName, rBase, rTop, height, nLongitudes, nLatitudes);

 Podemos especificar una parte de una corona circular con la siguiente función de GLU.

gluPartialDisk (ringName, rlnner, rOuter, nRadii, nRings, startAngle, sweepAngle);

 Cuando hay que aplicar otras condiciones de iluminación y sombreado, utilizamos la constante G L U _ S M O O T H , que genera un vector normal para cada vértice de la superficie.


La camara

La Cámara
La cámara son nuestros ojos virtuales. Todo lo que ella vea será proyectado, discretizado y finalmente mostrado en nuestra ventanita del sistema operativo. Los parámetros a definir en cuanto a la cámara son:
  • Posición XYZ en el mundo 3D. La cámara debe posicionarse. En un juego arcade 3D típico la cámara nos da la visión frontal del mundo y se va moviendo a nuestro antojo con las teclas o el ratón.
  • Orientación. Una vez situada debe orientarse. Yo puedo estar quieto pero girar la cabeza y mirar hacía donde me venga en gana.
  • Dirección de "AT". Define hacia dónde estoy mirando, a qué punto concretamente.
En OpenGL lo tenemos fácil con:
gluLookAt(eyeX, eyeY, eyeZ, atX, atY, atZ, upX, upY, upZ);
glMatrixMode(GL_MODELVIEW);
En cuanto a los parámetros que demanda la función son los siguientes:
  • Coordenadas del "eye". Es literalmente la posición XYZ dónde colocar la cámara dentro del mundo.
  • Coordenadas del "at". Es el valor XYZ del punto al que queremos que mire la cámara. Un punto del mundo obviamente.
  • Coordenadas del vector "up". Si, es un vector y no un punto. Con él regularemos la orientación de la cámara. Este ha de ser el vector que "mira hacia arriba" si entendemos que el vector que mira hacia adelante es el que va del "eye" hasta el "at". Variando el "up" variamos la orientación y sinó mirad:























Codigo 16 de Abril


#include <GL/glut.h> // Once you include glut.h (you don't need gl.h or glu.h)  

GLfloat X = 0.0f; // Translate screen to x direction (left or right)
GLfloat Y = 0.0f; // Translate screen to y direction (up or down)
GLfloat Z = 0.0f; // Translate screen to z direction (zoom in or out)
GLfloat rotX = 0.0f; // Rotate screen on x axis
GLfloat rotY = 0.0f; // Rotate screen on y axis
GLfloat rotZ = 0.0f; // Rotate screen on z axis
GLfloat rotLx = 0.0f; // Translate screen by using the glulookAt function (left or right)
GLfloat rotLy = 0.0f; // Translate screen by using the glulookAt function (up or down)
GLfloat rotLz = 0.0f; // Translate screen by using the glulookAt function (zoom in or out)
void glDisplayLines(void); // Did declare the function
   // so I did not have to check for order of the functions
// Initialize the OpenGL window
void init(void)
{
    glClearColor (0.0, 0.0, 0.0, 0.0); // Clear the color
    glShadeModel (GL_FLAT); // Set the shading model to GL_FLAT
    glEnable (GL_LINE_SMOOTH);
    glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); // Set Line Antialiasing
}
// Draw the lines (x,y,z)
void display(void)
{
    glClear (GL_COLOR_BUFFER_BIT); // Clear the Color Buffer
    glPushMatrix();  // It is important to push the Matrix before calling
   // glRotatef and glTranslatef
    glRotatef(rotX,1.0,0.0,0.0); // Rotate on x
    glRotatef(rotY,0.0,1.0,0.0); // Rotate on y
    glRotatef(rotZ,0.0,0.0,1.0); // Rotate on z
    glTranslatef(X, Y, Z);  // Translates the screen left or right,
   // up or down or zoom in zoom out
    // Draw the positive side of the lines x,y,z
    glBegin(GL_LINES);
    glColor3f (0.0, 1.0, 0.0); // Green for x axis
    glVertex3f(0,0,0);
    glVertex3f(10,0,0);
    glColor3f(1.0,0.0,0.0); // Red for y axis
    glVertex3f(0,0,0);
    glVertex3f(0,10,0);
    glColor3f(0.0,0.0,1.0); // Blue for z axis
    glVertex3f(0,0,0);
    glVertex3f(0,0,10);
    glEnd();
    // Dotted lines for the negative sides of x,y,z
    glEnable(GL_LINE_STIPPLE);  // Enable line stipple to use a
    // dotted pattern for the lines
    glLineStipple(1, 0x0101);  // Dotted stipple pattern for the lines
    glBegin(GL_LINES);
    glColor3f (0.0, 1.0, 0.0);  // Green for x axis
    glVertex3f(-10,0,0);
    glVertex3f(0,0,0);
    glColor3f(1.0,0.0,0.0);  // Red for y axis
    glVertex3f(0,0,0);
    glVertex3f(0,-10,0);
    glColor3f(0.0,0.0,1.0);  // Blue for z axis
    glVertex3f(0,0,0);
    glVertex3f(0,0,-10);
    glEnd();
    glDisable(GL_LINE_STIPPLE);  // Disable the line stipple
    glPopMatrix();   // Don't forget to pop the Matrix
    glutSwapBuffers();
}
// This function is called whenever the window size is changed
void reshape (int w, int h)
{
    glViewport (0, 0, (GLsizei) w, (GLsizei) h); // Set the viewport
    glMatrixMode (GL_PROJECTION);  // Set the Matrix mode
    glLoadIdentity ();
    gluPerspective(75, (GLfloat) w /(GLfloat) h , 0.10, 100.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt (rotLx, rotLy, 15.0 + rotLz, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
}
// This function is used for the navigation keys
void keyboard (unsigned char key, int x, int y)
{
switch (key) {   // x,X,y,Y,z,Z uses the glRotatef() function
    case 'x': // Rotates screen on x axis
    rotX -= 0.5f;
    break;
    case 'X': // Opposite way
    rotX += 0.5f;
    break;
    case 'y': // Rotates screen on y axis
    rotY -= 0.5f;
    break;
    case 'Y': // Opposite way
    rotY += 0.5f;
    break;
    case 'z': // Rotates screen on z axis
    rotZ -= 0.5f;
    break;
    case 'Z': // Opposite way
    rotZ += 0.5f;
    break;
    // j,J,k,K,l,L uses the gluLookAt function for navigation
    case 'j':
    rotLx -= 0.2f;
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt (rotLx, rotLy, 15.0 + rotLz, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
    break;
    case 'J':
    rotLx += 0.2f;
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt (rotLx, rotLy, 15.0 + rotLz, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
    break;
    case 'k':
    rotLy -= 0.2f;
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt (rotLx, rotLy, 15.0 + rotLz, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
    break;
    case 'K':
    rotLy += 0.2f;
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt (rotLx, rotLy, 15.0 + rotLz, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
    break;
    case 'l':  // It has a special case when the rotLZ becomes
  // less than -15 the screen is viewed from the opposite side
    // therefore this if statement below does not allow rotLz be less than -15
    if(rotLz + 14 >= 0)
    rotLz -= 0.2f;          
    glMatrixMode(GL_MODELVIEW);   
    glLoadIdentity(); 
    gluLookAt (rotLx, rotLy, 15.0 + rotLz, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
    break;
    case 'L':
    rotLz += 0.2f;
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt (rotLx, rotLy, 15.0 + rotLz, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
    break;
    case 'b': // Rotates on x axis by -90 degree
    rotX -= 90.0f;
    break;
    case 'B': // Rotates on y axis by 90 degree
    rotX += 90.0f;
    break;
    case 'n': // Rotates on y axis by -90 degree
    rotY -= 90.0f;
    break;
    case 'N': // Rotates on y axis by 90 degree
    rotY += 90.0f;
    break;
    case 'm': // Rotates on z axis by -90 degree
    rotZ -= 90.0f;
    break;
    case 'M': // Rotates on z axis by 90 degree
    rotZ += 90.0f;
    break;
    case 'o': // Default, resets the translations vies from starting view
    case 'O':
    X = Y = 0.0f;
    Z = 0.0f;
    rotX = 0.0f;
    rotY = 0.0f;
    rotZ = 0.0f;
    rotLx = 0.0f;
    rotLy = 0.0f;
    rotLz = 0.0f;
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(rotLx, rotLy, 15.0f + rotLz, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f); 
    break;
}
    glutPostRedisplay(); // Redraw the scene
}
// called on special key pressed
void specialKey(int key, int x, int y) {
// The keys below are using the gluLookAt() function for navigation
// Check which key is pressed
switch(key) {
    case GLUT_KEY_LEFT : // Rotate on x axis
    X -= 0.1f;
    break;
    case GLUT_KEY_RIGHT : // Rotate on x axis (opposite)
    X += 0.1f;
    break;
    case GLUT_KEY_UP : // Rotate on y axis
    Y += 0.1f;
    break;
    case GLUT_KEY_DOWN : // Rotate on y axis (opposite)
    Y -= 0.1f;
    break;
    case GLUT_KEY_PAGE_UP: // Rotate on z axis
    Z -= 0.1f;
    break;
    case GLUT_KEY_PAGE_DOWN:// Rotate on z axis (opposite)
    Z += 0.1f;
    break;
}
    glutPostRedisplay(); // Redraw the scene
}
// Main entry point of the program
int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);  // Setup display mode to
      // double buffer and RGB color
    glutInitWindowSize (600,600); // Set the screen size
    glutCreateWindow("OpenGL 3D Navigation Program");
    init ();
    glutReshapeFunc(reshape);
    glutDisplayFunc(display);
    glutKeyboardFunc(keyboard); // set window's key callback
    glutSpecialFunc(specialKey); // set window's to specialKey callback
    glutMainLoop();
    return 0;
}