martes, 17 de abril de 2012

ELIPSES Y CIRCULOS

FUNCIONES OpenGL PARA CURVAS

Las rutinas para generar curvas básicas, como círculos y elipses, no están incluidas como funciones primitivas en la biblioteca OpenGL básica. Pero esta biblioteca sí que contiene funciones para dibujar spunes de Bézier, que son polinomios que se definen mediante un conjunto de puntos discreto. Y la utilidad OpenGL (GLU, OpenGL Ulility) tiene rutinas para cuádricas tridimensionales, como esferas y cilindros, además de rutinas para generar B-splines racionales, que son una clase genérica de Splines en la que están incluidas las curvas de Bézier, más simples.

Otro método que podemos utilizar para generar la gráfica de una curva simple consiste en aproximarla ulizando una polilinea. Basta con localizar un conjunto de puntos a lo largo del trayecto de la curva y conectar dichos puntos mediante segmentos de linea recta. Cuantas más secciones lineales incluyamos en la polilinea. más suave será la apariencia de la curva.

ALGORITMOS PARA LA GENERACION DE CIRCULOS

Puesto que el círculo es un componente muy frecuentemente utilizado en dibujos y gráficas, muchos paquetes gráficos incluyen un procedimiento para generar círculos completos o arcos circulares. Asimismo, en ocasiones hay disponible una función genérica en las bibliotecas gráficas para mostrar diversos tipos de curvas, incluyendo círculos y elipses.

La forma del circulo es similar en cada uno de los cuadrantes. Por tanto, si determinamos las posiciones de la curva en el primer cuadrante, podemos generar la sección circular del segundo cuadrante del plano i observando que ambas secciones son simétricas con respecto al eje y. Y la secciones circulares de los cuadrantes tercero y cuarto pueden obtenerse a partir de las secciones de los dos primeros cuadrantes considerando la simetría con respecto al eje v.

ALGORITMO DEL PUNTO MEDIO PARA GENERACIÓN DE CÍRCULOS

1.    Introducir el radio r y el centro del círculo (xv,yt) y luego establecer las coordenadas para el primer punto de la circunferencia de un círculo centrado en el origen mediante la fórmula

2.    Calcular el valor inicial del parámetro de decisión

3.    Para cada posición xy comenzando en k = 0, realizar la siguiente comprobación. Si pk < 0, el siguiente punto a lo largo de un círculo centrado en (0,0) será {xk+iJyk) y, P^=Pt+2xktl+\

4.    Determinar los puntos simétricos en los otros siete ociantes.

5.    Mover cada posición de píxel (x, y) calculada hasta la trayectoria circular centrada en (xc,yc) y dibujar los valores de coordenadas: x=x+xc , y = y+yc

6.    Repetir los Pasos 3 a 5 hasta que x > y.


ALGORITMOS DE GENERACIÓN DE ELIPSES

En termines simples, una elipse es un circulo alargado. También podemos escribir una elipse como un circulo modificado cuyo radio varía desde un valor máximo en una dirección hasta un valor mínimo en la dirección perpendicular.

Formas paramétricas

La ecuación paramétrica de una elipse con centro en (H,K) y siendo el semieje mayor y b el menor, es:


con no es el ángulo θ del sistema de coordenadas polares con origen en el centro de la elipse (tampoco es el ángulo del sistema de coordenadas polares con origen en algún foco de la elipse). La relación entre y θ es

La ecuación paramétrica de una elipse con centro en en la que el parámetro sea concordante con el ángulo polar respecto al centro desplazado es:


con . El parámetro es el ángulo de un sistema polar cuyo origen está centrado en .

Programa Carro

Codigo
#include <GL/glut.h>
GLfloat TrasX=0.0f;
GLfloat TrasY=0.0f;
GLfloat TrasZ=0.0f;
GLint ancho=400;
GLint alto=400;
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(0.25f, 0.25f, 0.25f);
 glScalef(5.0f,0.0f,5.0f);
   
 glBegin(GL_QUADS);      
    glVertex3f( 2.5f,-1.0f, -1.0f);
    glVertex3f( 2.5f,-1.0f,  1.0f);
    glVertex3f(-1.0f,-1.0f,  1.0f);
    glVertex3f(-1.0f,-1.0f, -1.0f);
    glEnd();
}
void carro(void)
{
   glColor3f(1.0f, 0.0f, 0.0f);
glTranslatef(0.0f, -2.0f, 0.0f);
glBegin(GL_POLYGON); //carro
glVertex3f(-1.5f,0.5f, -2.0f);
glVertex3f( 3.5f,0.5f, -2.0f);
glVertex3f(3.5f,2.0f, -2.0f);
glVertex3f(2.0f,2.0f, -2.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, -2.0f, -5.0f);
glRotatef(10, 1.0f, 0.0f, 0.0f);
glRotatef(10, 0.0f, 1.0f, 0.0f);
// dibuja piso
Piso();
// dibuja rueda
glLoadIdentity();
glTranslatef(3.0f,-1.5f,-1.0f);
glTranslatef(TrasX,TrasY,TrasZ);
glColor3f(0.0f, 0.0f, 0.0f);
glutSolidSphere(0.5f, 16, 16);



//dibuja 2da rueda
glLoadIdentity();
glColor3f(0.0f, 1.0f, 1.0f);
glLoadIdentity();
glTranslatef(TrasX,TrasY,TrasZ);
carro();
glLoadIdentity();
glTranslatef(-.5f,-1.5f,-1.0f);
glTranslatef(TrasX,TrasY,TrasZ);
glColor3f(0.0f, 0.0f, 0.0f);
glutSolidSphere(0.5f, 16, 16);
glFlush();
glutSwapBuffers();
}
void init()
{
    glClearColor(1,1,1,1);
    glEnable(GL_DEPTH_TEST);
    ancho = 400;
    alto = 400;
}
void idle()
{
    display();
}

void keyboard(unsigned char key, int x, int y)
{
    switch(key)
    {
    case 'p':
    case 'P':
  hazPerspectiva=1;
  reshape(ancho,alto);
 break;
    case 'o':
    case 'O':
  hazPerspectiva=0;
  reshape(ancho,alto);
 break;
    case 'a':
    case 'A':
  TrasX-=.10;
 break;
    case 's':
    case 'S':
  TrasX+=.10;
                break;
    }
}

int main(int argc, char **argv)
{
 glutInit(&argc, argv);
 glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
 glutInitWindowPosition(100, 100);
    glutInitWindowSize(ancho, alto);
    glutCreateWindow("Carro");
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutIdleFunc(idle);
    glutKeyboardFunc(keyboard);
    glutMainLoop();
    return 0;
}




CORRIDA 
                                            



PREGUNTAS


ESCRIBA A MANERA DE REPORTE QUE  HACE  GLUTLOOKAT
Esta es la función que determina dónde y cómo está dispuesta la cámara. Cuidado que la posición de la cámara no tiene nada que ver con el tipo de proyección que hayamos definido. La proyección se define sólo una vez.

¿EN EL CÓDIGO HAGA  REFLEXION  SOBRE GLTRANSLATEF Y GLUTAT ()?

La función GLTRASLATE se utiliza para mover de un punto a otro un objeto y la función GLUTAT se usa para visualizar el objeto.

¿SE COMPORTAN DE LA MISMA MANERA?
No se comportan de la misma manera puesto que uno mueve el objeto y el otro mueve la cámara para visualizar el objeto.

PERO EN REALIDAD NO SON EXACTAMENTE LO MISMO, DEDUZCA  QUE DIFERENCIA EXISTE EN EL PROGRAMA

CODIGO 

#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;
}   

RESULTADO DE LA EJECUCION DEL CODIGO


jueves, 29 de marzo de 2012

PISO PELOTA

PROGRAMA
#include <GL/glut.h>

GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f;
GLfloat TrasEsferax= 3.0f;
GLfloat TrasEsferay= 0.0f;
GLfloat TrasEsferaz= -5.0f;

GLint ancho=400;
GLint alto=400;

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 drawCube(void)
{
    glColor3f(0.0f, 0.0f, 0.5f);
    glBegin(GL_QUADS);       //cara abajo
    glVertex3f( 2.0f,-2.0f, -2.0f);
    glVertex3f( 2.0f,-2.0f,  2.0f);
    glVertex3f(-2.0f,-2.0f,  2.0f);
    glVertex3f(-2.0f,-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(5, 1.0f, 0.0f, 0.0f);
   glRotatef(5, 0.0f, 1.0f, 0.0f);
    drawCube();
    glLoadIdentity();
    glTranslatef(TrasEsferax,TrasEsferay,TrasEsferaz);
    //glRotatef(anguloEsfera, 0.0f, 1.0f, 0.0f);
    //glTranslatef(0.0f, 3.0f, 0.0f);
    glColor3f(0.0f, 1.0f, 0.0f);
    glutWireSphere(0.5f, 8, 8);
    glFlush();
    glutSwapBuffers();
 //   anguloCuboX+=0.1f;
   // anguloCuboY+=0.1f;
    //anguloEsfera+=0.2f;
}
void init()
{
    glClearColor(0,0,0,0);
    glEnable(GL_DEPTH_TEST);
    ancho = 400;
    alto = 400;
}
 
void idle()
{
    display();
}

void keyboard(unsigned char key, int x, int y)
{
    switch(key)
    {
    case 'p':
    case 'P':
 hazPerspectiva=1;
 reshape(ancho,alto);
 break;

    case 'o':
    case 'O':
 hazPerspectiva=0;
 reshape(ancho,alto);
 break;
 case 'a':
    case 'A':
    TrasEsferax-=1.0;
  break;
 case 'd':
    case 'D':
    TrasEsferax+=1.0;
  break;
 case 'w':
    case 'W':
    TrasEsferay+=1.0;
  break;
 case 's':
    case 'S':
    TrasEsferay-=1.0;
  break;
 case 'g':
    case 'G':
    TrasEsferaz+=0.5;
  break;
 
 case 'c':
    case 'C':
    TrasEsferaz-=0.5;
  break;

    case 27:   // escape
// exit(0);
      break;
    }
}

int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(ancho, alto);
    glutCreateWindow("Piso y pelota");
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutIdleFunc(idle);
    glutKeyboardFunc(keyboard);
    glutMainLoop();
    return 0;
}
RESULTADOS





ACTIVIDAD 2 RESUMEN

OPENGL
·         Proyección: Trasforman una escena 3d “abstracta”, en una imagen plana que puede ser visualizada en una pantalla.
·         Viewport: Ajustan el producto de la proyección a las dimensiones de un rectángulo contenedor (ventana).
·   De vista: Que definen y afectan la posición desde la cual se visualizan las escenas tridimensionales.
·         Modelado: Sirven para manipular los objetos en la escena, permitiendo trasladarlos, rotarlos y deformarlos (escalarlos).
·         Modelo-Vista: Son la combinación de las dos transformaciones anteriores, que desde un punto de vista práctico son semejantes. 


 
  •  void glMatrixMode( enum mode ); Permite seleccionar la matriz sobre la cual se realizaran las operaciones, los posibles valores de mode son TEXTURE, MODELVIEW, COLOR o PROJECTION . Por ahora las más interesantes son MODELVIEW y PROJECTION, las otras se verán en su momento.
  • Void glLoadMatrix{fd} (T m[16]); Recibe una matriz de 4×4 que reemplaza la actual seleccionada. El arreglo es ordenado en forma de una matriz que tiene orden Y, a diferencia de las matrices convencionales que tienen orden X, lo que quiere decir que tiene la forma:     m = [a1 ,a2 ,a3 ,a4 ,a5 ,a6 ,a7 ,a8 ,a9 ,a10, a11, a12, a13, a14, a15, a16]
  • void glMultMatrix{fd}( T m[16] ); Multiplica la matriz actual por la matriz m[16] y reemplaza la matriz actual con el resultado de la operación. La operación resultante sería algo así como A’ = A M , donde A es la matriz actual, M es la matriz suministrada y A’ es la nueva matriz que resulta de la operación y que reemplaza a A.
  • void glLoadTransposeMatrix{fd}( T m[16] ); Realiza una función similar a LoadMatrix(
  • void glMultTransposeMatrix{fd}( T m[16] ); Misma funcionalidad que MultMatrix() , solo que actúa en base al la matriz en orden X, o sea la transpuesta.
  • void glLoadIdentity( void ); Remplaza la matriz actual por la matriz identidad de tamaño 4×4.
  • void glPushMatrix( void ); Coloca una copia de la matriz actual en la parte superior de la pila correspondiente.
  • void glPopMatrix( void ); Saca el elemento superior de la pila, que pasa a reemplazar a la matriz actual. 
TRANSFORMACIONES EN OPENGL
PROYECCIÓN
Como ya se ha visto en tutoriales anteriores, OpenGL maneja 2 tipos de proyección en perspectiva y ortográfica.
PRESPECTIVA.-  corresponde a la visión “realista” de la escena, mientras que la segunda es una “plana” que no deforma las dimensiones de los objetos dependiendo de su distancia a la cámara.
ORTOGRÁFICA: Para ajustar la proyección ortográfica se utiliza el siguiente grupo de funciones:
glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far);
Esta función permite controlar los parámetros del volumen de vista izquierdo, derecho, abajo, arriba, cerca y lejos. Hay que recordar que debido a que no se posee percepción de profundidad en este modo el valor del volumen deberá corresponder en la mayoría de los casos a un volumen suficientemente grande para contener los objetos de la escena.
gluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top);
Esta función es simplemente una forma de la anterior, en donde se ha despreciado el valor de Z asignando los valores near = -1 y far = 1, generalmente se utiliza para escenas planas, en las que los objetos carecen de profundidad.
Perspectiva: Existen dos manera de manejar la proyección en perspectiva, a través de de una función gl o mediante la librería glu (una tercera puede ser realizar los cálculos de la matriz “manualmente”. En el primer caso:
glFrustrum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)
Esta función crea una matriz y la multiplica por la matriz de proyección actual.
Transformaciones ModelView
Una tarea muy común en la creación de gráficos 2d, 3d y videojuegos es la de mover objetos par crear cierta animación. La primera idea que se nos viene a la cabeza en el caso de OpeGL es que todo modelo está formado por primitivas, toda primitiva por puntos y finalmente todo punto por una tripleta de coordenadas XYZ, así que si se cambian las coordenadas todo de ahí hacia arriba se mueve.
Después de un tiempo tal vez se requieran realizar unas tareas un poco mas complicadas como rotar el objeto alrededor de su centro, o alrededor de la posición donde se encuentra con respecto al sistema coordenada. Esta tarea no es tan simple y requiere algo de conocimiento en matemático para hacerse, debido a que probablemente implique la implementación de un sistema para almacenar y operar matrices, implementación de coordenadas homogéneas, etc. OpenGL provee de estos sistemas y utiliza algunas simples funciones para su acceso, contando con tres operaciones básicas: mover, rotar y escalar un conjunto de vértices.
void glRotate[fd](GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
Realiza una rotación del espacio coordenado por una medida de (angle) tomados en grados a lo largo del vector determinado por (x,y,z). Es recomendable que (x,y,z) representen un vector normalizado (o sea magnitud(x,y,z) = 1), debido a que si no es así OpenGL intentará normalizarlo. La rotación se lleva siguiendo la regla de la mano derecha, teniendo en cuenta que el vector (x,y,z) apunta con el “pulgar” hacia adentro (hacia uno).
void glTranslate[fd](GLfloat x, GLfloat y, GLfloat z);
Esta función traslada el espacio coordenado en x, y, z unidades sobre sus respectivos ejes coordenados X, Y, Z.
void glScalef(GLfloat x, GLfloat y, GLfloat z);
Cambia la proporción de los objetos respecto a los ejes coordenados, lo que es equivalente a decir que los estira o encoge una cantidad determinada por los parámetros de la función x,y,z.



COORDENADAS OCULARES
Las coordenadas oculares se sitúan en el punto de vista del observador, sin importar las transformaciones que tengan lugar.

TRANSFORMACIONES
Las transformaciones son las que hacen posible la proyección de coordenadas 3D sobre superficies 2D. También son las encargadas de mover, rotar y escalar objetos.

TRANSFORMACIONES DEL OBSERVADOR
La transformación del observador es la primera que se aplica a la escena, y se usa para determinar el punto más ventajoso de la escena.
TRANSFORMACIONES DEL MODELO
Estas transformaciones se usan para situar, rotar y escalar los objetos de la escena.
TRANSFORMACIONES DE LA PROYECCIÓN
 La transformación de proyección se aplica a la orientación final del modelador. Esta proyección define el volumen de visualización y establece los planos de trabajo.
TRANSFORMACIONES DE LA VISTA
 En el momento en que se ha terminado todo el proceso de transformaciones, solo queda un último paso: proyectar lo que hemos dibujado en 3D al 2D de la pantalla, en la ventana en la que estamos trabajando. Esta es la denominada transformación de la vista.
 MATRICES
 Las matemáticas que hay tras estas transformaciones se simplifican gracias a las matrices. Cada una de las transformaciones de las que se acaba de hablar puede conseguirse multiplicando una matriz que contenga los vértices por una matriz que describa la transformación.
LA MATRIZ DE PROYECCIÓN 
La matriz de proyección especifica el tamaño y la forma del volumen de visualización. El volumen de visualización es aquel cuyo contenido es el que se representa en pantalla.
PROYECCIONES ORTOGRÁFICAS
Una proyección ortográfica es cuadrada en todas sus caras. Esto produce una proyección paralela, útil para aplicaciones de tipo CAD o dibujos arquitectónicos, o también para tomar medidas, ya que las dimensiones de lo que representan no se ven alteradas por la proyección.
PROYECCIÓN ORTOGONAL
Una proyección ortogonal define un volumen de la vista de tipo paralelepipédico
PROYECCIONES PERSPECTIVAS
Una proyección en perspectiva reduce y estirar los objetos más alejados del observador.