Conceptos Aspect Ratio, Viewports y Pipeline Grafico

Investigar los siguientes conceptos:

Aspect ratio:
La relación de aspecto, ratio, ratio de aspecto, proporción de aspecto o razón de aspecto (traducciones literales de la expresión en inglés aspect ratio) de una imagen es la proporción entre su ancho y su altura. Se calcula dividiendo el ancho por la altura de la imagen visible en pantalla, y se expresa normalmente como «X:Y».

Viewports o visor: 
Un viewport es una región rectangular visualización en gráficos de computadora, o un término utilizado para los componentes ópticos. Ventana de recorte o de visualizacion.

Pipeline Grafico: 
Para llevar a cabo una representación virtual de un ambiente tridimensional, se realiza un modelado del escenario. Dicho modelo incluye la representación geométrica de los objetos presentes, las condiciones de iluminación de la escena y el lugar dentro de la misma desde dónde es apreciada. Cada objeto es representado a través de combinaciones, más o menos complejas, de figuras geométricas, el color o las texturas de sus superficies, y su posición y orientación en la escena. Luego se configuran las condiciones de iluminación, es decir posición, color, tipo y demás atributos de cada fuente de luz presente en la escena. Por último, se determina la posición y dirección del punto de vista o de la cámara a través de la cual se visualiza el ambiente. La visualización del ambiente en un dispositivo, como la pantalla de un monitor, es posible gracias a software y hardware especializado. Dicha especialización permite dibujar eficientemente sobre una pantalla bidimensional la proyección, comúnmente en perspectiva, de una escena tridimensional.
Pipeline de OpenGL: 
La mayoría de las implementaciones de OpenGL tienen un orden similar de operaciones, una serie de etapas de procesamiento de llamada de la canalización de representación de OpenGL.Este orden, como se muestra en la Figura , no es una regla estricta de cómo se implementa OpenGL, pero proporciona una guía confiable para predecir lo que va a hacer OpenGL.
--------------------------------------------------------------------------------------------------------------------------------

PRISMA TRIANGULAR ROTACION

#include <stdlib.h>
#include <GL/glut.h>

GLfloat   angX=0.0f;
GLfloat   angY=0.0f;

void reshape( int width, int height)
{
glViewport(0,0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-13,17,-15,15,-15,15);
glMatrixMode(GL_MODELVIEW);
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,0.0,0.0);
glLoadIdentity();

glRotatef(angX,1,0,0);
glRotatef(angY,0,1,0);

glBegin(GL_TRIANGLES);
glColor3f(1.0,0.0,0.0);
glVertex3f(0,0,0);
glVertex3f(0,0,3);
glVertex3f(1.5,3,1.5);
glVertex3f(0,0,0);
glEnd();
glBegin(GL_TRIANGLES);
glColor3f(0.0,1.0,0.0);
glVertex3f(3,0,0);
glVertex3f(3,0,3);
glVertex3f(1.5,3,1.5);
glVertex3f(3,0,0);
glEnd();
glBegin(GL_TRIANGLES);
glColor3f(0.0,0.0,1.0);
glVertex3f(0,0,3);
glVertex3f(3,0,3);
glVertex3f(1.5,3,1.5);
glVertex3f(0,0,3);
glEnd();
glBegin(GL_TRIANGLES);
glColor3f(1.0,1.0,0.0);
glVertex3f(0,0,0);
glVertex3f(3,0,0);
glVertex3f(1.5,3,1.5);
glVertex3f(0,0,0);
glEnd();

glBegin(GL_POLYGON);
glColor3f(1.0,0.0,1.0);
glVertex3f(0,0,0);
glVertex3f(3,0,0);
glVertex3f(3,0,3);
glVertex3f(0,0,3);
glEnd();

glFlush();
glutSwapBuffers();
    angX+=0.1f;
    angY+=0.1f;
}
 void init()
{
glClearColor(0,0,0,0);
//glEnable(GL_DEPTH_TEST);
}

void idle()
{
    display();
}

int main (int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowPosition(50,50);
glutInitWindowSize(500,500);
glutCreateWindow("PRISMA TRIANGULAR");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutMainLoop();
return 0;
}

CODIGO CREACION DEL PRISMA

include <stdlib.h>
#include <GL/glut.h>

void reshape( int width, int height)
{
glViewport(0,0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-3,7,-5,5,-5,5);
glMatrixMode(GL_MODELVIEW);
}

void display()

{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,0.0,0.0);
glLoadIdentity();

glBegin(GL_TRIANGLES);

glColor3f(1.0,0.0,0.0);
glVertex3f(0,0,0);
glVertex3f(0,0,3);
glVertex3f(1.5,3,-1.5);
glVertex3f(0,0,0);
glEnd();

glBegin(GL_TRIANGLES);
glColor3f(0.0,1.0,0.0);
glVertex3f(3,0,0);
glVertex3f(3,0,3);
glVertex3f(1.5,3,-1.5);
glVertex3f(3,0,0);
glEnd();

glBegin(GL_TRIANGLES);
glColor3f(0.0,0.0,1.0);
glVertex3f(0,0,3);
glVertex3f(3,0,3);
glVertex3f(1.5,3,-1.5);
glVertex3f(0,0,3);
glEnd();
glBegin(GL_TRIANGLES);
glColor3f(1.0,1.0,0.0);
glVertex3f(0,0,0);
glVertex3f(3,0,0);
glVertex3f(1.5,3,-1.5);
glVertex3f(0,0,0);
glEnd();

glBegin(GL_POLYGON);
glColor3f(1.0,0.0,1.0);
glVertex3f(0,0,0);
glVertex3f(3,0,0);
glVertex3f(3,0,3);
glVertex3f(0,0,3);
glEnd();

glFlush();

}

void init()
{
glClearColor(0,0,0,0);
}

int main (int argc, char **argv)

{

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(50,50);
glutInitWindowSize(500,500);
glutCreateWindow("PRISMA TRIANGULAR");

init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

9.- VECTOR Y RASTER

Formatos  son de imagen rasterizada y que formatos de imagen vetorial

La apariencia de los píxeles en una imagen después de una transformación geométrica (en particular cuando se la amplía) se denomina pixelación (también conocida como efecto escalonado). Además, las imágenes vectoriales  permiten definir una imagen con muy poca información, por lo que los archivos son bastante pequeños.

Por otra parte, una imagen vectorial sólo permite la representación de formas simples. Si bien es verdad que la superposición de varios elementos simples puede producir resultados impresionantes, no es posible describir todas las imágenes con vectores; éste es particularmente el caso de las fotografías realistas.

Imagen bitmap: como su nombre indica esta basada en un mapa de bits. Esto significa que cada bit (mínima unidad de información en este caso el píxel) se puede manipular individualmente. Así son imágenes que contienen más cantidad de información y por tanto más megas que las vectoriales. Los formatos de estas imágenes son, entre otros, jpg, tif o bmp. Y los programas actos para manipularlas son, por ejemplo, el gimp o el photoshop.

Imagen vectorial: Las imágenes vectoriales se construyen a partir de vectores. Los vectores son objetos formados matemáticamente. Un vector se define por una serie de puntos que tienen unas manecillas con las que se puede controlar la forma de la línea que crean al estar unidos entre sí. Los principales elementos de un vector son las curvas Béizer (curvas representadas matemáticamente).
Por tanto se basan en fórmulas matemáticas y superficies de color plano o que siguen una norma, como por ejemplo un degradado.

vectorial	mapa de bits

Imagen Rasterizada

Una imagen rasterizada esta compuesta de finos puntos llamados pixeles. Cuando estos pixeles son pequeños y puestos muy juntos, estos engañan al ojo y se ven como una imagen completa.
Las imágenes rasterizadas trabajan bien cuando subtle gradations de color son necesarias.

Imágenes vectoriales e imágenes de mapa de bits

imágenes vectoriales: las imágenes vectoriales son representaciones de entidades geométricas tales como círculos, rectángulos o segmentos. Están representadas por fórmulas matemáticas (un rectángulo está definido por dos puntos; un círculo, por un centro y un radio; una curva, por varios puntos y una ecuación). El procesador "traducirá" estas formas en información que la tarjeta gráfica pueda interpretar.

Dado que una imagen vectorial está compuesta solamente por entidades matemáticas, se le pueden aplicar fácilmente transformaciones geométricas a la misma (ampliación, expansión, etc.), mientras que una imagen de mapa de bits, compuesta por píxeles, no podrá ser sometida a dichas transformaciones sin sufrir una pérdida de información llamada distorsión. 

8.- CUBO EN 2D

----------------------------------------------

                CUBO EN 2D

----------------------------------------------

#include "stdafx.h"

#include <GL/glut.h>
void reshape( int width, int height)
{
glViewport(0,0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-3,7,-5,5,-5,5);
glMatrixMode(GL_MODELVIEW);
}

void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1,1,1);
glLoadIdentity();
glBegin(GL_LINE_LOOP);
glVertex2f(0,0);
glVertex2f(3,0);
glVertex2f(3,-3);
glVertex2f(0,-3);
glVertex2f(0,0);
glVertex2f(-2,1);
glVertex2f(-2,-2);
glVertex2f(0,-3);
glEnd();
glBegin(GL_LINE_LOOP);
glVertex2f(3,0);
glVertex2f(1,1);
glVertex2f(-2,1);
glVertex2f(-2,-2);
glVertex2f(1,-2);
glVertex2f(1,1);
glEnd();
glBegin(GL_LINE_LOOP);
glVertex2f(1,-2);
glVertex2f(3,-3);

glEnd();
glFlush();
}

void init()
{
glClearColor(0,0,0,0);
}
int main (int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(50,50);
glutInitWindowSize(500,500);
glutCreateWindow("CUBO 2D");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

7.- PRISMA TRIANGULAR

--------------------------------------------------------------

                  PRISMA TRIANGULAR

--------------------------------------------------------------

#include <stdlib.h>

#include <GL/glut.h>

void reshape( int width, int height)

{

glViewport(0,0, width, height);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

glOrtho(-3,7,-5,5,-5,5);

glMatrixMode(GL_MODELVIEW);

}

void display()

{

glClear(GL_COLOR_BUFFER_BIT);

glColor3f(1.0,0.0,0.0);

glLoadIdentity();

glBegin(GL_TRIANGLES);

glColor3f(1.0,0.0,0.0);

glVertex3f(0,0,0);

glVertex3f(0,0,3);

glVertex3f(1.5,3,-1.5);

glVertex3f(0,0,0);

glBegin(GL_TRIANGLES);

glColor3f(0.0,1.0,0.0);

glVertex3f(3,0,0);

glVertex3f(3,0,3);

glVertex3f(1.5,3,-1.5);

glVertex3f(3,0,0);

glBegin(GL_TRIANGLES);

glColor3f(0.0,0.0,1.0);

glVertex3f(0,0,3);

glVertex3f(3,0,3);

glVertex3f(1.5,3,-1.5);

glVertex3f(0,0,3);

glBegin(GL_TRIANGLES);

glColor3f(1.0,1.0,0.0);

glVertex3f(0,0,0);

glVertex3f(3,0,0);

glVertex3f(1.5,3,-1.5);

glVertex3f(0,0,0);

glEnd();

glFlush();

}

 void init()

{

glClearColor(0,0,0,0);

}

int main (int argc, char **argv)

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);

glutInitWindowPosition(50,50);

glutInitWindowSize(500,500);

glutCreateWindow("PRISMA TRIANGULAR");

init();

glutDisplayFunc(display);

glutReshapeFunc(reshape);

glutMainLoop();

return 0;

}

CUBO EN 2D

TRANSFORMACIONES GEOMETRICAS

El estudiante conocerá y aplicará las principales transformaciones geométricas sobre objetos en 2D y 3D.

Traslación

Se aplica una traslación en un objeto para cambiar su posición a lo largo de la trayectoria de una línea recta de una dirección de coordenadas a otra.

La traslación es una transformación de cuerpo rígido que mueve objetos sin deformarlos.

Los polígonos se trasladan al sumar el vector de traslación a la posición de coordenadas de cada vértice y se vuelve a generar el polígono utilizando un nuevo conjunto de coordenadas y vértices y las especificaciones actuales de los atributos.

ROTACION

Se aplica una rotación bidimensional en un objeto al cambiar su posición a lo largo de la trayectoria de una circunferencia en el plano de x y. para generar una rotación, especificamos un ángulo de rotación θ y la posición (xr, yr) del punto de rotación (o punto pivote) en torno al cual se gira el objeto.

Los valores positivos para el ángulo de rotación definen rotaciones en sentido opuesto a las manecillas del reloj alrededor del punto pivote y los valores negativos giran los objetos en la dirección del reloj.

ESCALACION

Una transformación de escalación altera el tamaño de un objeto. Se puede realizar esta operación para polígonos al multiplicar los valores de coordenadas de cada vértice por los factores de escalación para producir las coordenadas transformadas.

Podemos controlar la localización de unos objetos escalado al seleccionar una posición llamada punto fijo, que debe permanecer sin cambios después de la transformación de escalación.

ROTACION

Se aplica una rotación bidimensional en un objeto al cambiar su posición a lo largo de la trayectoria de una circunferencia en el plano de x y. Para generar una rotación especificamos un ángulo de rotación y la posición Xr’ Yr’ del punto de rotación o punto pivote en torno al cual se gira el objeto.

ESCALACION 2D Y 3D

2D

Nos permitirá cambiar las dimensiones de un objeto.

Requiere 2 parámetros:

             x  = Factor de escalación en X

             y  = Factor de escalación en Y

             x,y > 1    Aumenta la dimensión

             x,y < 1    Disminuye la dimensión    

             x,y = 1    Se mantiene la dimensión

3D

Nos permitirá cambiar las dimensiones de un objeto.

Requiere 3 parámetros:

            x  = Factor de escalación en X

            y  = Factor de escalación en Y

            z  = Factor de escalación en Z

     x,y,z > 1    Aumenta la dimensión

     x,y,z < 1    Disminuye la dimensión    

     x,y,z = 1    Se mantiene la dimensión

GLOSARIO

---------------------------------------------------------------------------------------------------------------------------------------------

ADC.-  (Convertidor Analógico-Digital) para poder discretizar la imagen y procesarla. 

APIs.-  Grupo de rutinas (conformando una interfaz) que provee un sistema operativo, una aplicación o una biblioteca, que definen cómo invocar desde un programa un servicio que éstos prestan. 

BUSES.-   es un sistema digital que transfiere datos entre los componentes de una computadora o entre computadoras.

COORDENADAS HOMOGENEAS.-  son un instrumento usado para describir un punto en el espacio proyectivo.

GRAFICACION.-  Representación de datos, casi siempre numéricos, aunque también pueden ser figuras o signos, a través de líneas superficies o símbolos para determinar la relación que estos mantienen entre sí. 

HDTV.-  Crónimo en inglés de High Definition Television o Televisión de alta definición. Formato caracterizado por emitir señales de televisión en más alta calidad. 

JPEG.-  Formato de imagen en el web que fue creado para reducir la talla de las fotografías al comprimirlas. JPEG se refiere al formato de los ficheros gráficos que utiliza este estándar de compresión. 

LZW.-  Es un algoritmo de compresión sin pérdida desarrollado por Terry Welch en 1984,

TARGETA DE VIDEO.-  Es una tarjeta que presenta un circuito impreso para transformar las señales eléctricas procedentes del microprocesador de una computadora en información que 
puede ser representada a través del monitor. 

MIDI.-  Se trata de un protocolo de comunicación serial estándar que permite a os computadores, sintetizadores, secuenciadores, controladores y otros dispositivos musicales electrónicos comunicarse y compartir información para la generación de sonidos. 

MPEG.-  Son las siglas de Moving Picture Experts Group y se pronuncia m-peg. MPEG es un grupo de la ISO y la familia de estándares de compresión y de formatos de archivo de video digital desarrollados por el grupo. 

MP3.-  Es el nombre de la extensión de archivo y también el nombre del tipo de archivo para MPEG, capa audio 3.  

PNG.-   Formato gráfico comprimido sin pérdida de calidad. Sus archivos tienen la extensión ".png". Es un formato abierto. 
SGI.- Provee hardware y software para computadoras.  

UXGA.-  Es una norma de visualización de gráficos de ordenador. Abreviatura de "Ultra eXtended Graphics Array". La resolución de éste formato es de 1600x1200 que constituyen una imagen de 1.920.000 píxeles, equivalente a aproximadamente 1.9 Megapixeles. 

XML.-  Permite que los diseñadores creen sus propias etiquetas, permitiendo la definición, transmisión, validación e interpretación de datos entre aplicaciones y entre organizaciones. 

 WAV.-  Es el formato para almacenar sonido en archivos desarrollado en común por Microsoft e IBM.
SVG.-  Lenguaje abierto que permite crear gráficos vectoriales 2D basado en XML, tanto estáticos y como animados. 

Actividad a: diseñar un programa para dibujar su cubo en dos dimensiones


Actividad b:

Investigar que es :

1. Una imagen rasterizada
2. Una imagen vectorial
3. Que formatos son de imagen rasterizada y que formatos de imagen vetorial

--------------------------------------------------------------------------------------------------------------------------------

Una imagen rasterizada esta compuesta de finos puntos llamados pixeles. Cuando estos pixeles son pequeños y puestos muy juntos, estos engañan al ojo y se ven como una imagen completa.
Las imágenes rasterizadas trabajan bien cuando subtle gradations de color son necesarias.
Debido a que continen un número fijo de pixeles, la mayor desventaja de las imagenes rasterizadas es que su calidad se ve afectada cuando se alargan o transforman las imagenes. También es grande su tamaño de archivo.

Imágenes de mapa de bits

Existen dos categorías principales de imágenes:imágenes de mapa de bits (también denominadas imágenes raster): son imágenes pixeladas, es decir que están formadas por un conjunto de puntos (píxeles) contenidos en una tabla. Cada uno de estos puntos tiene un valor o más que describe su color.
imágenes vectoriales: las imágenes vectoriales son representaciones de entidades geométricas tales como círculos, rectángulos o segmentos. Están representadas por fórmulas matemáticas (un rectángulo está definido por dos puntos; un círculo, por un centro y un radio; una curva, por varios puntos y una ecuación). El procesador "traducirá" estas formas en información que la tarjeta gráfica pueda interpretar.

Dado que una imagen vectorial está compuesta solamente por entidades matemáticas, se le pueden aplicar fácilmente transformaciones geométricas a la misma (ampliación, expansión, etc.), mientras que una imagen de mapa de bits, compuesta por píxeles, no podrá ser sometida a dichas transformaciones sin sufrir una pérdida de información llamada distorsión. La apariencia de los píxeles en una imagen después de una transformación geométrica (en particular cuando se la amplía) se denomina pixelación (también conocida como efecto escalonado). Además, las imágenes vectoriales (denominadas clipart en el caso de un objeto vectorial) permiten definir una imagen con muy poca información, por lo que los archivos son bastante pequeños.

Por otra parte, una imagen vectorial sólo permite la representación de formas simples. Si bien es verdad que la superposición de varios elementos simples puede producir resultados impresionantes, no es posible describir todas las imágenes con vectores; éste es particularmente el caso de las fotografías realistas.

Imagen bitmap: como su nombre indica esta basada en un mapa de bits. Esto significa que cada bit (mínima unidad de información en este caso el píxel) se puede manipular individualmente. Así son imágenes que contienen más cantidad de información y por tanto más megas que las vectoriales. Los formatos de estas imágenes son, entre otros, jpg, tif o bmp. Y los programas actos para manipularlas son, por ejemplo, el gimp o el photoshop.

Imagen vectorial: Las imágenes vectoriales se construyen a partir de vectores. Los vectores son objetos formados matemáticamente. Un vector se define por una serie de puntos que tienen unas manecillas con las que se puede controlar la forma de la línea que crean al estar unidos entre sí. Los principales elementos de un vector son las curvas Béizer (curvas representadas matemáticamente).
Por tanto se basan en fórmulas matemáticas y superficies de color plano o que siguen una norma, como por ejemplo un degradado.

Opengl jueves 29 Agosto

Actividad práctica

1. Investigue que es opengl
2. Como instalar las librerías
3. Probar el siguiente código
4. Los resultados de la actividad deben publicarse en su blog , incluyendo una captura de la pantalla donde se muestra los resultados de la ejecución del programa, la secuencia de pasos que realizó desde la instalación de la s librerías, fecha de revision lunes 2 de Septiembre

--------------------------------------------------------------------------------------------

1.- Open Graphics Library
OpenGL () es una especificación estándar que define una API multilenguaje y multiplataforma para escribir aplicaciones que produzcan gráficos 2D y 3D. La interfaz consiste en más de 250 funciones diferentes que pueden usarse para dibujar escenas tridimensionales complejas a partir de primitivas geométricas simples, tales como puntos, líneas y triángulos. Fue desarrollada originalmente por Silicon Graphics Inc. (SGI) en 1992 y se usa ampliamente en CAD, realidad virtual, representación científica, visualización de información y simulación de vuelo.
OpenGL tiene dos propósitos esenciales:

• Ocultar la complejidad de la interfaz con las diferentes, presentando al programador una API única y uniforme.
• Ocultar las diferentes capacidades de las diversas plataformas hardware, requiriendo que todas las implementaciones soporten la funcionalidad completa de OpenGL (utilizando emulación software si fuese necesario).

El funcionamiento básico de OpenGL consiste en aceptar primitivas tales como puntos, líneas y polígonos, y convertirlas en píxeles. Este proceso es realizado por una pipeline gráfica conocida como Máquina de estados de OpenGL.La mayor parte de los comandos de OpenGL bien emiten primitivas a la pipeline gráfica o bien configuran cómo la pipeline procesa dichas primitivas. Hasta la aparición de la versión 2.0 cada etapa de la pipeline ejecutaba una función prefijada, resultando poco configurable. A partir de la versión 2.0 algunas etapas son programables usando un lenguaje de programación llamado GLSL.

2.- INSTALAR LIBRERIAS
Configurar Code::Blocks para poder trabajar con OpenGL.
Code::Blocks es un entorno de desarrollo integrado libre, gratuito y multiplataforma para el desarrollo de programas en lenguaje C++.
Lo primero que tendremos que hacer es bajarnos la última versión de Code::Blocks desde su página oficial: codebloks.org y acceder a la sección Downloads:
codebloks.org/download/binaries donde procederemos a descarganos la versión que incluye en compilador GCC y el GDB debugger de MinGW. En mi caso esta:
codeblocks-10.05mingw-setup.exe
Una vez desgargado simplemente tendremos que ejecutar el instalador. Al terminar la instalación y ejecutar Code::Blocks tendremos que establecer el compilador por defecto, en nuestro caso utilizaremos GNU GCC como pre-determinado.
GLUT
Ya tenemos Code::Blocks instalado, pero nos falta configurar las librerias de OpenGL para empezar a utilizar esta API tan potente.

Necesitaremos GLUT, (del inglés OpenGL Utility Toolkit), que es una biblioteca de utilidades para programas OpenGL que principalmente proporciona diversas funciones de entrada/salida con el sistema operativo. Los dos objetivos de GLUT son permitir la creación de código más portable entre diferentes sistemas operativos (GLUT es multiplataforma) y hacer OpenGL más simple. Y dicho esto… manos a la obra:

1. Tendremos que dirigirnos a la página web de Nate Robins: xmission.com/~nate/glut.html y descargarnos los binarios del OpenGL Utility Toolkit (GLUT).
2. Una vez hecho esto tendremos que descomprimir el ZIP en una carpeta de nombre GLUT.
3. Crearemos en la carpeta recién creada “GLUT” las carpetas “bin“, “include” y “lib“. Dentro de la carpeta “include” tendremos que crear también la subcarpeta “GL“.
4. En la carpeta “GL“, que está dentro de “include” tendremos que copiar el archivo “glut.h“
5. En la carpeta “lib” tendremos que copiar el archivo “glut32.lib“
6. Por último tendremos que copiar en la “bin” el archivo “glut32.dll“