Reporte práctica 2

Desarrollo Práctica 2

1.- Ejecutar el código del previo:

TETRAEDRO:



CUBO:






2.- Desarrolle un código que:
a) Dibuje un triángulo en pantalla

#include 

void display(void)
{

 glClear(GL_COLOR_BUFFER_BIT);
 glColor3f(.5,.5,.5);
 

 // Triangulo  
 glBegin(GL_TRIANGLES);
  glVertex3f(0,0,-1);
  glVertex3f(1,0,-1);
  glVertex3f(0,1,-1);
 glEnd();
glFlush();
}

void reshape(float width, float height)
{
 //glViewport(0,0,width,height);
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();
 glOrtho(-6,6,-6,6,-6,6);
}

int main(int argc, char **argv)
{
 glutInit( &argc, argv); 
 glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
 glutInitWindowPosition(20,20);
 glutInitWindowSize(320,320);
 glutCreateWindow(" practica 2");
 glClearColor(0,0,0,0);

 glutDisplayFunc(display);
 glutReshapeFunc(reshape);
 glutMainLoop();

 return 0;
}

b) Dibuje un pentagono (no necesariamente regular).

#include 

void display(void)
{

 glClear(GL_COLOR_BUFFER_BIT);
 glColor3f(.5,.5,.5);
 
// pentagono con lineas
 glBegin(GL_LINES);
  glVertex3f(-1,0,-1);
  glVertex3f(-1.5,0,-1);
  
  glVertex3f(-1.5,0,-1);
  glVertex3f(-1.6,.25,-1);
  
  glVertex3f(-1.6,.25,-1);
  glVertex3f(-1.2,.5,-1);
  
  glVertex3f(-1.2,.5,-1);  
  glVertex3f(-1,.25,-1);
  
  glVertex3f(-1,.25,-1);
  glVertex3f(-1,0,-1);
 glEnd();
 
glFlush();
}

void reshape(float width, float height)
{
 //glViewport(0,0,width,height);
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();
 glOrtho(-6,6,-6,6,-6,6);
}

int main(int argc, char **argv)
{
 glutInit( &argc, argv); 
 glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
 glutInitWindowPosition(20,20);
 glutInitWindowSize(320,320);
 glutCreateWindow(" practica 2");
 glClearColor(0,0,0,0);

 glutDisplayFunc(display);
 glutReshapeFunc(reshape);
 glutMainLoop();

 return 0;
}

c) cambie la primitiva del dibujo y dibuje el pentagono como:
- conjunto de puntos
- líneas
- tira de líneas
- triángulos
- tira de triángulos
- abanico detriángulos
- cuadrilateros
- poligono

/*
 * Eduardo Granados Ch.
 * Lab de computación gráfica
 * Programa de pentagonos con difernetes primitivas
 */

#include 

void display(void)
{

 glClear(GL_COLOR_BUFFER_BIT);
 glColor3f(.5,.5,.5);
 
 
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();
 glTranslatef(-3.5,0,0); 
 // 1.- PENTAGONO CON PUNTOS
 glBegin(GL_POINTS);
  glVertex3f(0,0,-1);
  glVertex3f(.4,0,-1);
  
  glVertex3f(.4,0,-1);
  glVertex3f(.5,.2,-1);
  
  glVertex3f(.5,.2,-1);
  glVertex3f(.2,.4,-1);
  
  glVertex3f(.2,.4,-1);  
  glVertex3f(-.1,.2,-1);
  
  glVertex3f(-.1,.2,-1);
  glVertex3f(0,0,-1);
 glEnd();
 
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();
 glTranslatef(-2.5,0,0);
 // 2.- PENTAGONO CON LINEAS
 glBegin(GL_LINES);
  glVertex3f(0,0,-1);
  glVertex3f(.4,0,-1);
  
  glVertex3f(.4,0,-1);
  glVertex3f(.5,.2,-1);
  
  glVertex3f(.5,.2,-1);
  glVertex3f(.2,.4,-1);
  
  glVertex3f(.2,.4,-1);  
  glVertex3f(-.1,.2,-1);
  
  glVertex3f(-.1,.2,-1);
  glVertex3f(0,0,-1);
 glEnd();
 
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();
 glTranslatef(-1.5,0,0);
 // 3.- PENTAGONO CON TIRAS DE LINEAS
 glBegin(GL_LINE_STRIP);
  glVertex3f(0,0,-1);
  glVertex3f(.4,0,-1);
  
  glVertex3f(.4,0,-1);
  glVertex3f(.5,.2,-1);
  
  glVertex3f(.5,.2,-1);
  glVertex3f(.2,.4,-1);
  
  glVertex3f(.2,.4,-1);  
  glVertex3f(-.1,.2,-1);
  
  glVertex3f(-.1,.2,-1);
  glVertex3f(0,0,-1);
 glEnd();
 
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();
 glTranslatef(-.5,0,0);
 // 4.- PENTAGONO CON TRIANGULOS
 glBegin(GL_TRIANGLES);
  glVertex3f(0,0,-1);
  glVertex3f(.4,0,-1);
  
  //glVertex3f(.4,0,-1);   // si se descomenta esta linea no se ve la imagen
  glVertex3f(.5,.2,-1);     // porque el tercer vertice es igual al primero
  
  glVertex3f(.5,.2,-1);
  glVertex3f(.2,.4,-1);
  
  //glVertex3f(.2,.4,-1);  // si se descomenta esta linea no se ve la imagen
  glVertex3f(-.1,.2,-1);    // porque el tercer vertice es igual al primero
  
  glVertex3f(-.1,.2,-1);
  glVertex3f(0,0,-1);;
 glEnd();
 

 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();
 glTranslatef(.5,0,0);
 // 5.- PENTAGONO CON TIRA DE TRIANGULOS 
 glBegin(GL_TRIANGLE_STRIP);  
  glVertex3f(0,0,-1);
  glVertex3f(.4,0,-1);
  
  //glVertex3f(.4,0,-1);   // si se descomenta esta linea no se ve la imagen
  glVertex3f(.5,.2,-1);    // porque el tercer vertice es igual al primero
  
  glVertex3f(.5,.2,-1);
  //glVertex3f(.2,.4,-1);  // si se descomenta esta linea no se ve la imagen
                           // porque el tercer vertice es igual al primero
  glVertex3f(.2,.4,-1);  
  glVertex3f(-.1,.2,-1);
  
  glVertex3f(-.1,.2,-1);
  glVertex3f(0,0,-1);
 glEnd();
 

 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();
 glTranslatef(1.5,0,0);
 // 6.- PENTAGONO CON ABANICO DE TRIANGULOS 
 glBegin(GL_TRIANGLE_FAN); 
  glVertex3f(0,0,-1);
  glVertex3f(.4,0,-1);
  
  glVertex3f(.4,0,-1);
  glVertex3f(.5,.2,-1);
  
  glVertex3f(.5,.2,-1);
  glVertex3f(.2,.4,-1);
  
  glVertex3f(.2,.4,-1);  
  glVertex3f(-.1,.2,-1);
  
  glVertex3f(-.1,.2,-1);
  glVertex3f(0,0,-1);
 glEnd();
 

 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();
 glTranslatef(2.5,0,0);
 // 7.- PENTAGONO CON CUADRILATEROS 
 glBegin(GL_QUADS); 
  glVertex3f(0,0,-1);
  glVertex3f(.4,0,-1);
  
  glVertex3f(.4,0,-1);
  glVertex3f(.5,.2,-1);
  
  glVertex3f(.5,.2,-1);
  glVertex3f(.2,.4,-1);
  
  glVertex3f(.2,.4,-1);  
  glVertex3f(-.1,.2,-1);
  
  glVertex3f(-.1,.2,-1);
  glVertex3f(0,0,-1);
 glEnd();
 
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();
 glTranslatef(3.5,0,0);
 // 8.- PENTAGONO CON POLIGONO
 glBegin(GL_POLYGON); 
  glVertex3f(0,0,-1);
  glVertex3f(.4,0,-1);
  
  glVertex3f(.4,0,-1);
  glVertex3f(.5,.2,-1);
  
  glVertex3f(.5,.2,-1);
  glVertex3f(.2,.4,-1);
  
  glVertex3f(.2,.4,-1);  
  glVertex3f(-.1,.2,-1);
  
  glVertex3f(-.1,.2,-1);
  glVertex3f(0,0,-1);
 glEnd();

 glFlush();
}

void reshape(float width, float height)
{
 //glViewport(0,0,width,height);
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();
 glOrtho(-4,4,-1,1,-1,1);
}

int main(int argc, char **argv)
{
 glutInit( &argc, argv); 
 glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
 glutInitWindowPosition(20,20);
 glutInitWindowSize(400,400);
 glutCreateWindow(" practica 2");
 glClearColor(0,0,0,0);

 glutDisplayFunc(display);
 glutReshapeFunc(reshape);
 glutMainLoop();

 return 0;
}

3.- Muestre las pantallas.

Previo Practica 2

                                    Cuestionario previo #2 
                                 Práctica del 19 de febrero de 2008 
                                    - Principios básicos - 


1. ¿Qué es una transformación geométrica? 
¿Cuáles son las transformaciones básicas y sus matrices? 

Una transformación geométrica es una función matemática que 
transforma un punto o conjunto de puntos en otro punto o 
conjunto de puntos, dentro del sistema de referencia global de 
la escena. 

Las tres transformaciones básicas son la traslación, la rotación y el 
escalado. 

TRASLACIÓN 
Consiste en modificar la posición de 
un punto en el plano definido por las coordenadas (x, y), 
mediante un movimiento en línea recta desde la posición actual 
(posición inicial) a la posición final. 

A los valores dx y dy se les denomina distancias de traslación.
Estas distancias son números reales positivos o negativos.

 

ROTACIÓN.
desplaza un punto a través de la
circunferencia definida sobre un centro determinado, es decir,
siguiendo un movimiento circular.
esta operación no modifica la
geometría del objeto, sólo su posición.

ESCALADO.
modifica la distancia de los puntos sobre los que se aplica, respecto a un punto de referencia. Para definir esta operación son necesarios dos factores de escala, Sx y Sy, según las direcciones x e y, y un punto o eje de referencia.

2. Escriba los comandos que en OpenGL permiten aplicar transformaciones geométricas, las variantes de dichos comandos y describa sus parámetros. 

Traslación
 glTraslatef(float x, float y,float z);
 x, y, z: puede ser positivo o negativo, es la distancia que se movera el objeto.

Rotación
 glRotate(alfa, float x, float y, float z);
 alfa: ángulo que girara
 x, y, z: vector sobre el que girara.

Escalado:
 glScalf(float x, float y, float z);
 x,y,z: factor de escala respecto a los ejes x, y, z.



3.Describa los comandos que en OpenGL se utilizan para definir vértices y sus parámetros. Escriba un ejemplo de cada uno. 

 glVertex3f(float x, float y, float z);
 x, y, z: es el punto en el espacio donde se ubicara.


4.¿Para qué sirven los comandos glBegin() y glEnd()? Describa su uso, sus parámetros y ejemplifique a través de una pieza de código. 

Nos sirven para crear figuras como: lineas, triangulos, cuadrados, puntos. Los parametros de glBegin();
pueden ser los siguientes:

GL_LINES   Lineas 
GL_LINES_STRIP         Lineas en trozos, se van uniendo las lineas
GL_TRIANGLES         Triángulos
GL_TRIANGLES_STRIP Triángulos a trozos, se van uniendo los triangulos
GL_QUADS  Cuadrados
GL_QUADS_STRIP         Cuadrados a trozos, se van uniendo.
GL_POINTS  Puntos

El siguiente ejemplo dibuja un triangulo, en el plano Z=0, sus vertices son: (0,0,0), (1,0,0) y (0,1,0)

 glBegin(GL_TRIANGLES);
  glVertex3f(0,0,0);
  glVertex3f(1,0,0);
  glVertex3f(0,1,0);
 glEnd();
   

5.Construya código para dibujar un cubo y una pirámide de base triángular (tetraedro). Las medidas corren por su cuenta. 

TETRAEDRO
#include 

void reshape(int width, int height) 
{ 
 glViewport(0,0,width,height); 
 glMatrixMode(GL_PROJECTION); 
 glLoadIdentity(); 
 gluPerspective(60,(GLfloat)((width/height)/10), 2,15.0); 
 //glOrtho(-3,3,-3,3,-6,3); 
} 


void display() 
{ 
 glColor3f(.8f, .81f, .8f); 
 glClear(GL_COLOR_BUFFER_BIT);  // se limpian   los   buffers de dibujo y profundidad 

 glMatrixMode(GL_MODELVIEW); 
 glLoadIdentity();   

 glTranslatef(0,0,-.1); 
 glRotatef(20,0,1,0); 
 glScalef(0.5,.5,.5); 

 glutWireTetrahedron(); 
  
 glFlush();  // guarda comandos como peticiones en pila, ejecutra     los comandos de pila.. 
  
} 

 
int main(int argc, char **argv) 
{ 
    glutInit(&argc, argv);   // se inicializa el GLUT, mismos   
   // parametros de main y crea una ventana 

    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); //modo de dibujo de 
     // ventana. GLUT_SINGLE- un buffer. GLUT_RGB - modelo del color 

    glutInitWindowPosition(30, 30); // posicion de la ventana 

    glutInitWindowSize(500, 500);  // tamaño de la ventana 
    glutCreateWindow("Tetraedro"); // propiamente crea la venta,       con su nombre 

    glClearColor(0,0,0,0); // color alque se borra el buffer, (rgbAlfa) 
   //glEnable(GL_DEPTH_TEST);  //actva profundidad 

 // muestra el fondo de la ventana 
    glutDisplayFunc(display); // ayuda a GLUT para redibujar por      alguna razon, arg es ua funcion 

    glutReshapeFunc(reshape);  // ayuda a GLUT para redibujar por     que es reescalada, se pas d arg una func 



    glutMainLoop();  // cede ctls a GLUT para detectar eventos 

    return 0; 
} 



CUBO

#include 

void dibujaCubo(void)  // cra un cubo 
{ 
    glColor3f(1.0f, 0.0f, 0.0f); 
    glBegin(GL_QUADS); //cara frontal 
    glVertex3f(-1.0f, -1.0f, 1.0f); 
    glVertex3f( 1.0f, -1.0f, 1.0f); 
    glVertex3f( 1.0f, 1.0f, 1.0f); 
    glVertex3f(-1.0f, 1.0f, 1.0f); 
    glEnd(); 
    glColor3f(0.0f, 1.0f, 0.0f); 
    glBegin(GL_QUADS); //cara trasera 
    glVertex3f( 1.0f, -1.0f, -1.0f); 
    glVertex3f(-1.0f, -1.0f, -1.0f); 
    glVertex3f(-1.0f, 1.0f, -1.0f); 
    glVertex3f( 1.0f, 1.0f, -1.0f); 
    glEnd(); 
    glColor3f(0.0f, 0.0f, 1.0f); 
    glBegin(GL_QUADS); //cara lateral izq 
    glVertex3f(-1.0f, -1.0f, -1.0f); 
    glVertex3f(-1.0f, -1.0f, 1.0f); 
    glVertex3f(-1.0f, 1.0f, 1.0f); 
    glVertex3f(-1.0f, 1.0f, -1.0f); 
    glEnd(); 
    glColor3f(1.0f, 1.0f, 0.0f); 
    glBegin(GL_QUADS); //cara lateral dcha 
    glVertex3f( 1.0f, -1.0f, 1.0f); 
    glVertex3f( 1.0f, -1.0f, -1.0f); 
    glVertex3f( 1.0f, 1.0f, -1.0f); 
    glVertex3f( 1.0f, 1.0f, 1.0f); 
    glEnd(); 
    glColor3f(0.0f, 1.0f, 1.0f); 
    glBegin(GL_QUADS); //cara arriba 
    glVertex3f(-1.0f, 1.0f, 1.0f); 
    glVertex3f( 1.0f, 1.0f, 1.0f); 
    glVertex3f( 1.0f, 1.0f, -1.0f); 
    glVertex3f(-1.0f, 1.0f, -1.0f); 
    glEnd(); 
    glColor3f(1.0f, 0.0f, 1.0f); 
    glBegin(GL_QUADS); //cara abajo 
    glVertex3f( 1.0f, -1.0f, -1.0f); 
    glVertex3f( 1.0f, -1.0f, 1.0f); 
    glVertex3f(-1.0f, -1.0f, 1.0f); 
    glVertex3f(-1.0f, -1.0f, -1.0f); 
    glEnd(); 
} 

void reshape(int width, int height) 
{ 
 glViewport(0,0,width,height); 
 glMatrixMode(GL_PROJECTION); 
 glLoadIdentity(); 
 gluPerspective(60,(GLfloat)((width/height)/10), 2,15.0); 
 //glOrtho(-3,3,-3,3,-6,3); 
} 


void display() 
{ 
 glColor3f(.8f, .81f, .8f); 
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  // se limpian   los buffers de dibujo y profundidad 

 glMatrixMode(GL_MODELVIEW); 
 glLoadIdentity();   

 glTranslatef(0,0,-.1); 
 glRotatef(20,1,1,-1.5); 
 glScalef(0.5,.5,.5); 
 
 dibujaCubo(); 
  
 glFlush();  // guarda comandos como peticiones en pila, ejecutra     los comandos de pila.. 
  
} 


int main(int argc, char **argv) 
{ 
    glutInit(&argc, argv);   // se inicializa el GLUT, mismos   
   // parametros de main y crea una ventana 

    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); //modo de dibujo de 
     // ventana. GLUT_SINGLE- un buffer. GLUT_RGB - modelo del color 

    glutInitWindowPosition(30, 30); // posicion de la ventana 

    glutInitWindowSize(500, 500);  // tamaño de la ventana 
    glutCreateWindow("Cubo"); // propiamente crea la venta,       con su nombre 
    glEnable(GL_DEPTH_TEST);  //actva profundidad 
    glClearColor(0,0,0,0); // color alque se borra el buffer, (rgbAlfa) 
   //glEnable(GL_DEPTH_TEST);  //actva profundidad 

 // muestra el fondo de la ventana 
    glutDisplayFunc(display); // ayuda a GLUT para redibujar por      alguna razon, arg es ua funcion 

    glutReshapeFunc(reshape);  // ayuda a GLUT para redibujar por     que es reescalada, se pas d arg una func 



    glutMainLoop();  // cede ctls a GLUT para detectar eventos 

    return 0; 
} 



6.¿Para qué sirven los comandos glClearColor() y glClear()? Descríbalos su funcionamiento, sus parámetros y ejemplifique a través de una pieza de código.

void glClearColor(float R, float, G, float B, float alpha);
Donde R, G, B: van de cero a uno, sirve para borrar dando de fondo el color indicado. Alpha, también va de cero a uno
glClear();
Fija el área de mapa de bits de la ventana a valores preestablecidos por glClearColor.

glClearIndex, glClearDepth, glClearStencil, y glClearAccum.
Sus argumentos son: GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT, GL_STENCIL_BUFFER_BIT


7.Describa los comandos glutInit(), glutInit(), glutInitDisplayMode(), glutInitWindowSize(), glutInitWindowPosition(), glutCreateWindow(), glutDisplayFunc(), glutReshapeFunc(), glutKeyboardFunc() y glutMainLoop(). Describa su funcionamiento, uso y parámetros.


 glutInit()
 Indica que dara inicio GLUT. Su notación es    glutInit(&argc, argv);  sus parametros son los mismos  de la entrada del main();
 int main(int argc, char **argv)

 {

     glutInit(&argc, argv);
 ...}

glutInitDisplayMode ();
Inicializa el modo del display, algunos de sus argumentos pueden ser: GLUT_SINGLE,  GLUT_RGB, GLUT_DOUBLE, 
glutInitWindowSize (float x, float y );
Inidca el tamaño de la ventana inicial. x ancho, y alto

glutInitWindowPosition (float x, float y);
Indica donde aparecera la ventana, especificamente la ezquina superior izquierda. 

glutCreateWindow (String name);
Esta funcion es la que propiamente crea la ventana con el argumento del nombre.

glutDisplayFunc(function);
Es una funcion de callback, su argumento es una función, por lo regular llamada display();
sirve para redibujar la pantalla (contenido) , es aqui donde se despliega el desarrollo de las escenas.


glutReshapeFunc() 
También e suna función de callback, con las mismas caracteristicas de glutDisplayFunc(); pero esta función ayuda para el reescalamiento de la ventana, o movida. la funcion reshere tiene como argumentos el ancho y alto de la venta. se define asi:
void reshape(int width, int height);

glutKeyboardFunc() 
También e suna función de callback, para darle un tratamiento al teclado. el parametro utilizado es 
la función Keyboard que esta tiene de argumentos:
unsigned char key, int x, int y: char, es el ASCII de la tecla presionada y x,y la posición del mouse en se momento.
void keyboard(unsigned char key, int x, int y);



glutMainLoop();
Es un loop infinito, para esatr atento a las funcionces de callback. el program nunca saldra, a menso que se especifique un exit.

Práctica 1 "instalando openGL sobre windows"

Es curioso entregar reportes de prácticas por blog XD.

Objetivo:

Instalar las librerias de openGL sobre windows (vista) para compilar y ejecutar programas de prueba.

Procedimiento:

1.- Entrar a la pagina de openGL: www.opengl.org, dirigirse a la sección "codin resources/ GLUT &   
    utility libraries, About GLUT". y descargar los archivos:
          - GLUT 3.7 Source Code Download for Win32.zip
          - Pre-compiled Win32 for Intel GLUT 3.7 DLLs for Windows 95 & NT.zip

2.- Descomprimir ambos archivos en el escritorio.
    En el archivo descomprimido Pre-compiled Win32 for Intel GLUT 3.7 DLLs for Windows 95 & NT.zip  
    se tienen los siguintes archivos: glut.dll, glut.h, glut.lib, glut32.dll y glut32.lib.

3.- Con estos archivos se crea el sigueinte árbol de directorios en el escritorio

     Escritorio
         '-- Dev
              '-- dll
              |    '-- glut.dll
              |    '-- glut32.dll
              |
              '-- lib
              |    '-- glut.lib
              |    '-- glut32.lib
              |
              '-- include
                     '-- GL
                          '-- glut.h

4.- En seguida se debe agregar el directorio C:\~\Escritorio\Dev\dll al PATH.
    Para ello damos click derecho sobre el boton Inicio\Equipo\propiedades. En el menú nos  
    dirigimos a la pestaña Variables de entorno, despues a la opción de variables de usuario, 
    agregar la ruta anterior ( C:\~\Escritorio\Dev\dll ) y dar aceptar a todas las ventanas 
    desplegadas.

5.- Ya esta todo listo para comenzar a crear nuestro primer proyecto :D Para ello ocuparemos 
    Microsoft Visual Studio 2008. 
    Creamos un nuevo proyecto de C/C++, seleccionamos tipo de proyecto “aplicación de consola” y 
    también “Proyecto vacio” (empty project), llamaremos al proyecto “PrimerGrafico”  ;)

6.- Tenemos que agregar las librerias faltantes de GLUT/openGL para poder compilar nuestros 
    programas.Para ello nos dirigimos al menú Proyecto/Propiedades de Primer Gráfico/configuración 
    /propiedades/linker/general/incluir directorio adicional/ aqui agregamos la ruta del 
     directorio creado en el Paso 3,  C:\~\Escritorio\Dev\include y damos Aceptar.

7.- Seguimos agregando las librerias, damos click en el menú de Proyecto/Propiedades de 
    PrimerGrafico/Configuración/propiedades/linker/general/adicionar directorio de librerias  
    y agregamos C:\~\Escritorio\Dev\lib

8.- Ya esta todo listo para comenzar a escribir nuestro primer progama :D.
    Pero debido a que es nuestra primer práctica en opengl haremos un poco de “trampa”, tomaremos 
    código existente para compilarlo y ejecutarlo ;)

9.- Nos dirigimos al "Explorador de Soluciones" en la sección de “source files” y agregamos 
    nuestro programa ;) , en este caso agregamos
    C:\...\Escritorio\glut-3.7\progs\demos\glutmech\glutmech.c
    Vaya es bastante extenso.

10.- Compilamos, en el menú Proyecto/Compilar. ZzZzZ... Woow todo marcha bien y ahora sobre la 
     flecha verde damos "ejecutar/run" y como por arte de mágia vemos solo los vertices de un 
     robot, vaya que es sorprendente no???!!!!

11.- Podemos regresar al Paso 9 para agregar más codigos, compilarlos y ejecutarlos ;)

 Y listo a correr los demás programas :D   :D

Hola Mundo

Blog para mis reportes y previos del laboratorio de Computación Gráfica.

UNAM, FI.
Ing. en computación

Profesor Ing. Santiago Igor Valeinte g.
Grupo: 1
Me llamo Eduardo Granados Ch.

estare posteando en el transcurso del semestre!!