1.¿Qué es la animación?
El término animación viene del griego "anemos" = viento, aliento y del latín "animus" = dar vida. El concepto de animación se asocia habitualmente con el de movimiento. Podemos definir la animación por ordenador como la "generación, almacenamiento y presentación de imágenes que en sucesión rápida producen sensación de movimiento."
2. Animación por cinemática
La cinemática estudia los movimientos con independencia de las fuerzas que los producen. Este tipo se divide en 2:
--Directa.- A partir del grado de rotación de las articulaciones, se calcula la posición de la estructura articulada.
--Inversa.- a partir de una posición deseada de la estructura articulada, se calcula cuál debe ser el grado de rotación de las articulaciones. Para este problema puede haber cero, una o varias soluciones. El movimiento basado en cinemática inversa recuerda al de las marionetas con hilos.
3. Animación por keyframes
Es la técnica utilizada por los dibujos animados tradicionales. Los dibujantes expertos crean las imágenes claves de una animación tales como la de inicio o fin de un movimiento. A partir de estos fotogramas, el resto del equipo dibuja la serie de fotogramas que los conectan (proceso in-betweening).
4. Animación por captura de movimiento
Es una técnica de movimientos grabados digitalmente. Es la creación de representaciones en 3D de un movimiento ejecución real ya sea de u objeto o de algo tan detallado como lo es la cara de una persona. Estos movimientos son grabados como información de animación y después mapeados en un modelo 3D. Estos movimientos mapeados son los mismos que realizara el modelo 3D hacinedo que el modelo 3D y la persona o el objeto de la vida real tengan los mismos movimientos.
miércoles, 31 de octubre de 2007
miércoles, 24 de octubre de 2007
tarea: linea y curva de bresenham
#include
void init(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_FLAT);
}
void IluminaPixel (int x, int y)
{
glColor3f(0.5,0.5,0.5);
glBegin(GL_POINTS);
glVertex2f(x,y);
glEnd();
}
void TrazaLinea (int xa, int ya, int xb, int yb)
{
int dx=abs(xa-xb),dy=abs(ya-yb);
int p=2*dy-dx;
int twoDy=2*dy, twoDyDx=2*(dy-dx);
int posx, posy, xEnd;
if(xa > xb) {
posx = xb;
posy = yb;
xEnd=xa;
}
else {
posx= xa;
posy= ya;
xEnd= xb;
}
IluminaPixel (posx, posy);
while (posx < xEnd) {
posx++;
if (p > 0)
p += twoDy;
else {
posy++;
p += twoDyDx;
}
IluminaPixel (posx, posy);
}
}
void Bresenham (void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 1.0, 1.0);
glPushMatrix();
glTranslatef(0,0,0);
TrazaLinea(0,0,40,20);
glColor3f(0.5,0.5,0.5);
glBegin(GL_LINES);
glVertex2f(-10,-10);
glVertex2f(10,20);
glEnd();
glPopMatrix();
glFlush();
}
void reshape(int w, int h)
{
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho(-30, 75, -30, 35, -200, 100);
else
glOrtho(-5.0*(GLfloat)w/(GLfloat)h,
5.0*(GLfloat)w/(GLfloat)h, -5.0, 5.0, -5.0, 5.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 100);
glutCreateWindow ("Linea de Bresenham");
init ();
glutDisplayFunc(Bresenham);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}
void init(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_FLAT);
}
void IluminaPixel (int x, int y)
{
glColor3f(0.5,0.5,0.5);
glBegin(GL_POINTS);
glVertex2f(x,y);
glEnd();
}
void TrazaLinea (int xa, int ya, int xb, int yb)
{
int dx=abs(xa-xb),dy=abs(ya-yb);
int p=2*dy-dx;
int twoDy=2*dy, twoDyDx=2*(dy-dx);
int posx, posy, xEnd;
if(xa > xb) {
posx = xb;
posy = yb;
xEnd=xa;
}
else {
posx= xa;
posy= ya;
xEnd= xb;
}
IluminaPixel (posx, posy);
while (posx < xEnd) {
posx++;
if (p > 0)
p += twoDy;
else {
posy++;
p += twoDyDx;
}
IluminaPixel (posx, posy);
}
}
void Bresenham (void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 1.0, 1.0);
glPushMatrix();
glTranslatef(0,0,0);
TrazaLinea(0,0,40,20);
glColor3f(0.5,0.5,0.5);
glBegin(GL_LINES);
glVertex2f(-10,-10);
glVertex2f(10,20);
glEnd();
glPopMatrix();
glFlush();
}
void reshape(int w, int h)
{
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho(-30, 75, -30, 35, -200, 100);
else
glOrtho(-5.0*(GLfloat)w/(GLfloat)h,
5.0*(GLfloat)w/(GLfloat)h, -5.0, 5.0, -5.0, 5.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 100);
glutCreateWindow ("Linea de Bresenham");
init ();
glutDisplayFunc(Bresenham);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}
miércoles, 17 de octubre de 2007
TAREA: ALGORITMOS DE TRAZADO DE LINEAS
Algoritmo de Bresenham
Considerado uno de los algoritmos más efectivos para el trazo de líneas mediante rastreo. Emplea cálculos incrementales con valores enteros. La forma de determinar el siguiente pixel a iluminar en la generación de una línea, se describe a continuación: Se parte de un punto inicial P1(Xinicial,Yinicial). Luego se desplaza una columna (incrementando la posición en X) y se traza el pixel cuyo valor de Y de la línea de rastreo se aproxima más a la trayectoria de la línea.
Se capturan los dos extremos de la línea P1(Xinicial,Yinicial) y P2(Xfinal,Yfinal), se ilumina el primer pixel correspondiente al extremo izquierdo de la línea(P1). Luego se calculan los parámetros que permitien decidir cuál será el proximo pixel a iluminar (DeltaX, DeltaY y ConstanteP). Dependiendo del valor que tome el Parámetro ConstanteP se evalúa y determina la coordenada a iluminar que puede ser: (X+1,Y) para ConstanteP < 0, en caso contrario se ilumina (X+1,Y+1). El proceso anterior debe repetirse 4DeltaX veces.
El algoritmo es el siguinete:
Leer Coordenadas P1(Xinicial, Yinicial)
Leer Coordenadas P2(Xfinal, Yfinal)
Asignar a DeltaX el ABS( Xfinal - Xinicial)
Asignar a DeltaY el ABS( Yfinal -Yinicial)
Asignar a ConstanteP el resultado de 2*DeltaY - DeltaX
Si Xinicial > Xfinal
Asignar Xfinal a X
Asignar Yfinal a Y
Asignar Xinicial a Ultimo
De lo contrario
Asignar Xinicial a X
Asignar Yinicial a Y
Asignar a Xfinal a Ultimo
Iluminar pixel en coordenada X,Y
Hacer mientras X es menor a Ultimo
-Asignar X + 1 a X
-Si ConstanteP es mayor a 0
Asignar ConstanteP + 2 *DeltaY a ConstanteP
De lo contrario
Asignar Y+1 a Y
Asignar a ConstanteP el resultado de ConstanteP+2 *(DeltaY-DeltaX)
Iluminar pixel en coordenada X,Y
Fin de Algoritmo (Bresenham)*/
ALGORITMO DDA (Digital Differential Analyzer)
Es un algoritmo que se basa en el cálculo y la evaluación de un DeltaX (dX) y un DeltaY(dY). Por medio de las siguientes ecuaciones:
DeltaX = DeltaY /m DeltaY = m*DeltaX
Se efectúa un muestreo de la línea en intervalos unitarios en una coordenada y se determinan los valores enteros correspondientes más próximos a la trayectoria de la línea para la siguiente coordenada.
Se aceptan como datos de entradas las dos posiciones de los pixeles correspondientes a los extremos de la línea P1(Xinicial,Yinicial) y P2(Xfinal,Yfinal). Las diferencias horizontal y vertical entre las posiciones de los extremos dados, se asignan a las varialbles DeltaX y DeltaY respectivamente. La diferencia con la mayor magnitud determina el valor del parámetro Pasos. Se procede a determinar la compensación necesaria(incremento), para generar la posición del pixel siguiente a lo largo de la trayectoria de la línea. Luego, se ilumina la posición en la pantalla. y se repite este proceso cíclico Pasos Veces, hasta obtener la línea deseada.
El algoritmo es:
Leer Coordenadas P1(Xinicial, Yinicial)
Leer Coordenadas P2(Xfinal,Yfinal)
Asignar a DeltaX la diferencia de Xfinal - Xinicial
Asignar a DeltaY la diferencia de Yfinal - Yinicial
Si ABS( DeltaX) > ABS(DeltaY)
Asignar a Pasos el ABS(DeltaX)
De lo contrario
Asignar a Pasos el ABS(DeltaY)
Asignar a Xincremento el resultado de DeltaX / Pasos
Asignar a Yincremento el resultado de DeltaY / Pasos
Asignar a X el valor de Xinicial
Asignar a Y el valor de Yinicial
Iluminar pixel en coordenada X,Y
Desde k=1 hasta Pasos
Asignar a X la suma de X + Xincremento
Asignar a Y la suma de Y + Yincremento
Iluminar pixel en Coodenada X,Y
Fin de Algoritmo(DDA)
Considerado uno de los algoritmos más efectivos para el trazo de líneas mediante rastreo. Emplea cálculos incrementales con valores enteros. La forma de determinar el siguiente pixel a iluminar en la generación de una línea, se describe a continuación: Se parte de un punto inicial P1(Xinicial,Yinicial). Luego se desplaza una columna (incrementando la posición en X) y se traza el pixel cuyo valor de Y de la línea de rastreo se aproxima más a la trayectoria de la línea.
Se capturan los dos extremos de la línea P1(Xinicial,Yinicial) y P2(Xfinal,Yfinal), se ilumina el primer pixel correspondiente al extremo izquierdo de la línea(P1). Luego se calculan los parámetros que permitien decidir cuál será el proximo pixel a iluminar (DeltaX, DeltaY y ConstanteP). Dependiendo del valor que tome el Parámetro ConstanteP se evalúa y determina la coordenada a iluminar que puede ser: (X+1,Y) para ConstanteP < 0, en caso contrario se ilumina (X+1,Y+1). El proceso anterior debe repetirse 4DeltaX veces.
El algoritmo es el siguinete:
Leer Coordenadas P1(Xinicial, Yinicial)
Leer Coordenadas P2(Xfinal, Yfinal)
Asignar a DeltaX el ABS( Xfinal - Xinicial)
Asignar a DeltaY el ABS( Yfinal -Yinicial)
Asignar a ConstanteP el resultado de 2*DeltaY - DeltaX
Si Xinicial > Xfinal
Asignar Xfinal a X
Asignar Yfinal a Y
Asignar Xinicial a Ultimo
De lo contrario
Asignar Xinicial a X
Asignar Yinicial a Y
Asignar a Xfinal a Ultimo
Iluminar pixel en coordenada X,Y
Hacer mientras X es menor a Ultimo
-Asignar X + 1 a X
-Si ConstanteP es mayor a 0
Asignar ConstanteP + 2 *DeltaY a ConstanteP
De lo contrario
Asignar Y+1 a Y
Asignar a ConstanteP el resultado de ConstanteP+2 *(DeltaY-DeltaX)
Iluminar pixel en coordenada X,Y
Fin de Algoritmo (Bresenham)*/
ALGORITMO DDA (Digital Differential Analyzer)
Es un algoritmo que se basa en el cálculo y la evaluación de un DeltaX (dX) y un DeltaY(dY). Por medio de las siguientes ecuaciones:
DeltaX = DeltaY /m DeltaY = m*DeltaX
Se efectúa un muestreo de la línea en intervalos unitarios en una coordenada y se determinan los valores enteros correspondientes más próximos a la trayectoria de la línea para la siguiente coordenada.
Se aceptan como datos de entradas las dos posiciones de los pixeles correspondientes a los extremos de la línea P1(Xinicial,Yinicial) y P2(Xfinal,Yfinal). Las diferencias horizontal y vertical entre las posiciones de los extremos dados, se asignan a las varialbles DeltaX y DeltaY respectivamente. La diferencia con la mayor magnitud determina el valor del parámetro Pasos. Se procede a determinar la compensación necesaria(incremento), para generar la posición del pixel siguiente a lo largo de la trayectoria de la línea. Luego, se ilumina la posición en la pantalla. y se repite este proceso cíclico Pasos Veces, hasta obtener la línea deseada.
El algoritmo es:
Leer Coordenadas P1(Xinicial, Yinicial)
Leer Coordenadas P2(Xfinal,Yfinal)
Asignar a DeltaX la diferencia de Xfinal - Xinicial
Asignar a DeltaY la diferencia de Yfinal - Yinicial
Si ABS( DeltaX) > ABS(DeltaY)
Asignar a Pasos el ABS(DeltaX)
De lo contrario
Asignar a Pasos el ABS(DeltaY)
Asignar a Xincremento el resultado de DeltaX / Pasos
Asignar a Yincremento el resultado de DeltaY / Pasos
Asignar a X el valor de Xinicial
Asignar a Y el valor de Yinicial
Iluminar pixel en coordenada X,Y
Desde k=1 hasta Pasos
Asignar a X la suma de X + Xincremento
Asignar a Y la suma de Y + Yincremento
Iluminar pixel en Coodenada X,Y
Fin de Algoritmo(DDA)
martes, 16 de octubre de 2007
previo 8
1. ¿Qué es una curva/superficie paramétrica?
Sea C Una curva que consiste en todos los pares ordenados (f(t),g(t)), donde f y g son funciones continuas en un intervalo I. Las ecuaciones
x = f(t), y = (t)
Para t en I, se denominan ecuaciones paramétricas de C con parámetro t
Una superficie paramétrica es la imagen de una función o transformación r definida en una región R de un plano uv y que tiene valores en el espacio xyz. La imagen bajo r en cada punto (u,v) en R es el punto del espacio xyz con vector de posición.
r(u,v)= x(u,v), y(u,v), z(u,v)
Dado que una superficie paramétrica es una imagen de una transformación en el espacio, es posible por lo tanto tomar coordenadas cilíndricas y esféricas, para expresar la superficie con otros parámetros distintos a los rectangulares.
2. Describa los resultados aparentes y diferencias entre las familias de curvas:
BEZIER
Se denomina curvas de Bézier a un sistema que se desarrolló hacia los años 1960, para el trazado de dibujos técnicos, en el diseño aeronáutico y de automóviles. Su denominación es en honor a Pierre Bézier, quien ideó un método de descripción matemática de las curvas que se comenzó a utilizar con éxito en los programas de CAD.
La idea de definir geométricamente las formas no es demasiado compleja: un punto del plano puede definirse por coordenadas. Por ejemplo, un punto A tiene unas coordenadas (x1, y1) y a un punto B le corresponde (x2,y2). Para trazar una recta entre ambos basta con conocer su posición.
Si en lugar de unir dos puntos con una recta se unen con una curva, surgen los elementos esenciales de una curva Bézier: los puntos se denominan nodos o puntos de anclaje. La forma de la curva se define por unos puntos invisibles en el dibujo, denominados puntos de control, manejadores o manecillas. En general, para trazar segmentos rectos se hace clic con el útil de dibujo (la pluma), se mueve el ratón y se hace clic en un nuevo punto, y así sucesivamente. Para crear segmentos suaves, curvados, se hace clic y se mantiene apretado el botón mientras se ajusta la forma de la curva. Esta forma puede modificarse posteriormente, moviendo los puntos de control según se desee. Los segmentos rectos pueden conectarse con segmentos curvos.
SPLINE
un spline es una curva definida a trozos mediante polinomios. En los problemas de interpolación, se utiliza a menudo la interpolación mediante splines porque da lugar a resultados similares requiriendo solamente el uso de polinomios de bajo grado a la vez que se evitan las oscilaciones, que en la mayoría de las aplicaciones resultan indeseables, que aparecen al interpolar mediante polinomios de grado elevado.
Para el ajuste de curvas, los splines se utilizan para aproximar formas complicadas. La simplicidad de la representación y la facilidad de cómputo de los splines los hacen populares para la representación de curvas en informática, particularmente en el terreno de los gráficos por ordenador.
NURBS
Los NURBS (Non-Uniform Rational B-Splines) son entes matemáticos que definen exactamente una curva o superfice a partir de varios puntos de control, no necesariamente pertenecientes a la trayectoria, y unos pesos asociados a los mismos.
Cuanto mayor sea la complejidad de la curva, mayor será el número de puntos de control que deberá especificarse, pero, en todo caso, el número de puntos generados será menor que el necesario utilizando la aproximación tradicional por tramos rectos.
Curvas Nurbs
Son una herramienta importante para trabajar en 3D. Pueden ser una forma simple de modelar una superficie o un avanzado control para la animación, se definen por puntos de control, que controlan la forma de la curva. También consta de otros tipos de punto como los editables, que indica el principio o final de un segmento, y rectas que unen los puntos de control en una curva.
La geometría de la curva se define por: grados, puntos de control, nodos y regla de calculo.
Superficies Nurbs
Tienen los principios de las curvas nurbs, y se aplican igual, sin embargo una diferencia entre curvas y superficies es que las curvas se sometena una sola direccion y la superficie es bidireccional, estas bidireccion tiene un origen llamado normal, que determina la parte frontal o trasera de la misma.
3. Ventajas y desventajas de usar curvas/superficies paramétricas contra modelos de alta y baja densidad de polígonos.
El trazado de curvas y superficies paramétricas es más fácil de calcular y por ende se necesita de menos recursos y el trazado es más rápido. Una desventaja de esto es que a diferencia de los modelos con polígonos (mayormente los de alta densidad) el trazado de la recta es más precisa ya que se podría suponer que con los polígonos la distancia de los lados de los polígonos tiende a cero.
4. ¿Qué familias de curvas/superficies paramétricas están implementadas en OpenGL?
Splines, B-Splines y NURBS
5. ¿Cómo escribimos código que las defina y dibuje? dé dos ejemplos para cada tipo de curva/superficie.
//CURVA DE BEZIER
#include
#include
#include
#include
GLfloat ctrlpoints[4][3] = {
{ -4.0, -4.0, 0.0}, { -2.0, 4.0, 0.0},
{2.0, -4.0, 0.0}, {4.0, 4.0, 0.0}};
void init(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_FLAT);
glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, &ctrlpoints[0][0]);
glEnable(GL_MAP1_VERTEX_3);
}
void display(void)
{
int i;
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 1.0, 1.0);
glBegin(GL_LINE_STRIP);
for (i = 0; i <= 30; i++)
glEvalCoord1f((GLfloat) i/30.0);
glEnd();
/* The following code displays the control points as dots. */
glPointSize(5.0);
glColor3f(1.0, 1.0, 0.0);
glBegin(GL_POINTS);
for (i = 0; i < 4; i++)
glVertex3fv(&ctrlpoints[i][0]);
glEnd();
glFlush();
}
void reshape(int w, int h)
{
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho(-5.0, 5.0, -5.0*(GLfloat)h/(GLfloat)w,
5.0*(GLfloat)h/(GLfloat)w, -5.0, 5.0);
else
glOrtho(-5.0*(GLfloat)w/(GLfloat)h,
5.0*(GLfloat)w/(GLfloat)h, -5.0, 5.0, -5.0, 5.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}
//SUPERFICIE DE BEZIER
#include
#include
#include
#include
GLfloat ctrlpoints[4][4][3] = {
{{-1.5, -1.5, 4.0}, {-0.5, -1.5, 2.0},
{0.5, -1.5, -1.0}, {1.5, -1.5, 2.0}},
{{-1.5, -0.5, 1.0}, {-0.5, -0.5, 3.0},
{0.5, -0.5, 0.0}, {1.5, -0.5, -1.0}},
{{-1.5, 0.5, 4.0}, {-0.5, 0.5, 0.0},
{0.5, 0.5, 3.0}, {1.5, 0.5, 4.0}},
{{-1.5, 1.5, -2.0}, {-0.5, 1.5, -2.0},
{0.5, 1.5, 0.0}, {1.5, 1.5, -1.0}}
};
void display(void)
{
int i, j;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(1.0, 1.0, 1.0);
glPushMatrix ();
glRotatef(85.0, 1.0, 1.0, 1.0);
for (j = 0; j <= 8; j++) {
glBegin(GL_LINE_STRIP);
for (i = 0; i <= 30; i++)
glEvalCoord2f((GLfloat)i/30.0, (GLfloat)j/8.0);
glEnd();
glBegin(GL_LINE_STRIP);
for (i = 0; i <= 30; i++)
glEvalCoord2f((GLfloat)j/8.0, (GLfloat)i/30.0);
glEnd();
}
glPopMatrix ();
glFlush();
}
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4,
0, 1, 12, 4, &ctrlpoints[0][0][0]);
glEnable(GL_MAP2_VERTEX_3);
glMapGrid2f(20, 0.0, 1.0, 20, 0.0, 1.0);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_FLAT);
}
void reshape(int w, int h)
{
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho(-5.0, 5.0, -5.0*(GLfloat)h/(GLfloat)w,
5.0*(GLfloat)h/(GLfloat)w, -5.0, 5.0);
else
glOrtho(-5.0*(GLfloat)w/(GLfloat)h,
5.0*(GLfloat)w/(GLfloat)h, -5.0, 5.0, -5.0, 5.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}
Sea C Una curva que consiste en todos los pares ordenados (f(t),g(t)), donde f y g son funciones continuas en un intervalo I. Las ecuaciones
x = f(t), y = (t)
Para t en I, se denominan ecuaciones paramétricas de C con parámetro t
Una superficie paramétrica es la imagen de una función o transformación r definida en una región R de un plano uv y que tiene valores en el espacio xyz. La imagen bajo r en cada punto (u,v) en R es el punto del espacio xyz con vector de posición.
r(u,v)= x(u,v), y(u,v), z(u,v)
Dado que una superficie paramétrica es una imagen de una transformación en el espacio, es posible por lo tanto tomar coordenadas cilíndricas y esféricas, para expresar la superficie con otros parámetros distintos a los rectangulares.
2. Describa los resultados aparentes y diferencias entre las familias de curvas:
BEZIER
Se denomina curvas de Bézier a un sistema que se desarrolló hacia los años 1960, para el trazado de dibujos técnicos, en el diseño aeronáutico y de automóviles. Su denominación es en honor a Pierre Bézier, quien ideó un método de descripción matemática de las curvas que se comenzó a utilizar con éxito en los programas de CAD.
La idea de definir geométricamente las formas no es demasiado compleja: un punto del plano puede definirse por coordenadas. Por ejemplo, un punto A tiene unas coordenadas (x1, y1) y a un punto B le corresponde (x2,y2). Para trazar una recta entre ambos basta con conocer su posición.
Si en lugar de unir dos puntos con una recta se unen con una curva, surgen los elementos esenciales de una curva Bézier: los puntos se denominan nodos o puntos de anclaje. La forma de la curva se define por unos puntos invisibles en el dibujo, denominados puntos de control, manejadores o manecillas. En general, para trazar segmentos rectos se hace clic con el útil de dibujo (la pluma), se mueve el ratón y se hace clic en un nuevo punto, y así sucesivamente. Para crear segmentos suaves, curvados, se hace clic y se mantiene apretado el botón mientras se ajusta la forma de la curva. Esta forma puede modificarse posteriormente, moviendo los puntos de control según se desee. Los segmentos rectos pueden conectarse con segmentos curvos.
SPLINE
un spline es una curva definida a trozos mediante polinomios. En los problemas de interpolación, se utiliza a menudo la interpolación mediante splines porque da lugar a resultados similares requiriendo solamente el uso de polinomios de bajo grado a la vez que se evitan las oscilaciones, que en la mayoría de las aplicaciones resultan indeseables, que aparecen al interpolar mediante polinomios de grado elevado.
Para el ajuste de curvas, los splines se utilizan para aproximar formas complicadas. La simplicidad de la representación y la facilidad de cómputo de los splines los hacen populares para la representación de curvas en informática, particularmente en el terreno de los gráficos por ordenador.
NURBS
Los NURBS (Non-Uniform Rational B-Splines) son entes matemáticos que definen exactamente una curva o superfice a partir de varios puntos de control, no necesariamente pertenecientes a la trayectoria, y unos pesos asociados a los mismos.
Cuanto mayor sea la complejidad de la curva, mayor será el número de puntos de control que deberá especificarse, pero, en todo caso, el número de puntos generados será menor que el necesario utilizando la aproximación tradicional por tramos rectos.
Curvas Nurbs
Son una herramienta importante para trabajar en 3D. Pueden ser una forma simple de modelar una superficie o un avanzado control para la animación, se definen por puntos de control, que controlan la forma de la curva. También consta de otros tipos de punto como los editables, que indica el principio o final de un segmento, y rectas que unen los puntos de control en una curva.
La geometría de la curva se define por: grados, puntos de control, nodos y regla de calculo.
Superficies Nurbs
Tienen los principios de las curvas nurbs, y se aplican igual, sin embargo una diferencia entre curvas y superficies es que las curvas se sometena una sola direccion y la superficie es bidireccional, estas bidireccion tiene un origen llamado normal, que determina la parte frontal o trasera de la misma.
3. Ventajas y desventajas de usar curvas/superficies paramétricas contra modelos de alta y baja densidad de polígonos.
El trazado de curvas y superficies paramétricas es más fácil de calcular y por ende se necesita de menos recursos y el trazado es más rápido. Una desventaja de esto es que a diferencia de los modelos con polígonos (mayormente los de alta densidad) el trazado de la recta es más precisa ya que se podría suponer que con los polígonos la distancia de los lados de los polígonos tiende a cero.
4. ¿Qué familias de curvas/superficies paramétricas están implementadas en OpenGL?
Splines, B-Splines y NURBS
5. ¿Cómo escribimos código que las defina y dibuje? dé dos ejemplos para cada tipo de curva/superficie.
//CURVA DE BEZIER
#include
#include
#include
#include
GLfloat ctrlpoints[4][3] = {
{ -4.0, -4.0, 0.0}, { -2.0, 4.0, 0.0},
{2.0, -4.0, 0.0}, {4.0, 4.0, 0.0}};
void init(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_FLAT);
glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, &ctrlpoints[0][0]);
glEnable(GL_MAP1_VERTEX_3);
}
void display(void)
{
int i;
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 1.0, 1.0);
glBegin(GL_LINE_STRIP);
for (i = 0; i <= 30; i++)
glEvalCoord1f((GLfloat) i/30.0);
glEnd();
/* The following code displays the control points as dots. */
glPointSize(5.0);
glColor3f(1.0, 1.0, 0.0);
glBegin(GL_POINTS);
for (i = 0; i < 4; i++)
glVertex3fv(&ctrlpoints[i][0]);
glEnd();
glFlush();
}
void reshape(int w, int h)
{
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho(-5.0, 5.0, -5.0*(GLfloat)h/(GLfloat)w,
5.0*(GLfloat)h/(GLfloat)w, -5.0, 5.0);
else
glOrtho(-5.0*(GLfloat)w/(GLfloat)h,
5.0*(GLfloat)w/(GLfloat)h, -5.0, 5.0, -5.0, 5.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}
//SUPERFICIE DE BEZIER
#include
#include
#include
#include
GLfloat ctrlpoints[4][4][3] = {
{{-1.5, -1.5, 4.0}, {-0.5, -1.5, 2.0},
{0.5, -1.5, -1.0}, {1.5, -1.5, 2.0}},
{{-1.5, -0.5, 1.0}, {-0.5, -0.5, 3.0},
{0.5, -0.5, 0.0}, {1.5, -0.5, -1.0}},
{{-1.5, 0.5, 4.0}, {-0.5, 0.5, 0.0},
{0.5, 0.5, 3.0}, {1.5, 0.5, 4.0}},
{{-1.5, 1.5, -2.0}, {-0.5, 1.5, -2.0},
{0.5, 1.5, 0.0}, {1.5, 1.5, -1.0}}
};
void display(void)
{
int i, j;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(1.0, 1.0, 1.0);
glPushMatrix ();
glRotatef(85.0, 1.0, 1.0, 1.0);
for (j = 0; j <= 8; j++) {
glBegin(GL_LINE_STRIP);
for (i = 0; i <= 30; i++)
glEvalCoord2f((GLfloat)i/30.0, (GLfloat)j/8.0);
glEnd();
glBegin(GL_LINE_STRIP);
for (i = 0; i <= 30; i++)
glEvalCoord2f((GLfloat)j/8.0, (GLfloat)i/30.0);
glEnd();
}
glPopMatrix ();
glFlush();
}
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4,
0, 1, 12, 4, &ctrlpoints[0][0][0]);
glEnable(GL_MAP2_VERTEX_3);
glMapGrid2f(20, 0.0, 1.0, 20, 0.0, 1.0);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_FLAT);
}
void reshape(int w, int h)
{
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho(-5.0, 5.0, -5.0*(GLfloat)h/(GLfloat)w,
5.0*(GLfloat)h/(GLfloat)w, -5.0, 5.0);
else
glOrtho(-5.0*(GLfloat)w/(GLfloat)h,
5.0*(GLfloat)w/(GLfloat)h, -5.0, 5.0, -5.0, 5.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}
martes, 9 de octubre de 2007
Practica 6
1. ¿Qué es shading en términos de computación gráfica?
En computación gráfica, shading se refiere al proceso de alterar el color basado en el ángulo de incidencia de la luz y la distancia de la fuente de luz, lo anterior con el fin de producir efectos visuales parecidos a los que en la realidad se producen. El proceso de shading se lleva acabo durante el rendering.
2. ¿Qué es, como se declara y se utiliza en OpenGL/GLUT?
Una fuente de luz
Es el origen de donde provendrá la iluminación de nuestra escena en OpenGL. Para crear una fuente de luz primero se debe activar la iluminación en OpenGL esto se logra con la función glEnable(GL_LIGHTING) y después se debe activar una fuente de luz por separado con la posibilidad de tener hasta 8, esto con el comando glEnable(GL_LIGHTn) donde n es el índice de la luz que se quiere activar.
Un material
Es la forma en la que se va interactuar con la luz reflejando las diferentes componentes roja, verde y azul, en diferente intensidad.
Para declarar un material se utiliza la función:
void glMaterial{if}(GLenum face, GLenum pname, TYPE param);
En su primer parámetro recibe una bandera la cual indica que caras de nuestro objeto tendrán las características de nuestro material ya sean las caras frontales, las de atrás o todo el objeto, el siguiente parámetro es otra bandera que indica el tipo de atributo de nuestro material, ejemplo la componente difusa, la componente ambiental, el tercer parámetro es el color que tendrá ese atributo de nuestro material.
Una textura
En principio para trabajar con texturas se necesita poder cargar imágenes en el formato de nuestra elección. Ya que OpenGL no tiene implementado algún método para esto, se tiene que realizar esta tarea de manera independiente. Resuelto lo anterior se debe proceder a activar las texturas, esto se logra con glEnable(GL_TEXTURE_2D). Antes de poder asignar una textura a cualquier objeto es necesario que el objeto tenga asignadas sus propias coordenadas de textura. Después de cargar la imagen, se tiene que generar un identificador con el cual OpenGL hará referencia a dicha textura, esto se logra con la función void glGenTextures( GLsizei n, GLuint *texturas ). Con este identificador ahora podemos referenciar la textura para poder generarla y asignarle algunos atributos. Para generar la textura se utiliza glTexImage2D(), y glTexParameteri() para asignar algunos características.
3. ¿Cúales son los atributos y características que se pueden declarar en OpenGL/GLUT para manejo de?
Luces
Los principales atributos de una luz son la posición, la componente difusa que representa el color de la luz, la componente ambiental que es el color de la iluminación global, y la componente specular que es el color de la luz que será reflejada por los objetos.
Materiales
Las características de los materiales son la difusa que es el color mate del objeto, la componente ambiental que es la iluminación ambiental que afecta al color del objeto, la componente specular que será el color que reflejará y el brillo que representa la intensidad de la componente specular.
Texturas
En cuanto texturas algunos atributos referentes son los filtros que se utilizaran para tratar la imagen, texturas ambientales, texturas cúbicas, otro parámetro es el número de repeticiones de dicha textura, entre otros.
4. Escriba un programa donde:
Dibuje un cubo y asigne características de material que lo hagan verse como de madera:
Aplique una textura de madera al cubo (bitmap)
Aplique como textura su fotografía
El cambio de modo se hará con un clic de Mouse
#include
#include
#include
#include
#include
#include
#include
// Constantes -----------------------------------------------------------------
#define kWindowWidth 800
#define kWindowHeight 600
// Estructuras ----------------------------------------------------------------
typedef struct // Se crea una estructura
{
GLubyte *imageData; // Datos de la imagen
GLuint bpp; // Profundidad del color de la imagen en bits por pixel
GLuint width; // Ancho de la imagen
GLuint height; // Alto de la imagen
GLuint texID; // Numero identificador de la textura
} TextureImage; // Nombre de la estructura
// Prototipos -------------------------------------------------------
bool loadTGA(TextureImage *texture, char *filename);
GLvoid initGL(GLvoid);
GLvoid display(GLvoid);
GLvoid resize(int width, int height);
GLvoid mouse(int button,int state,int x,int y);
GLvoid idle(GLvoid);
GLvoid loadGLTextures(void);
GLvoid keyboard(unsigned char key, int x, int y);
void setMaterial( GLfloat ambr, GLfloat ambg, GLfloat ambb,
GLfloat difr, GLfloat difg, GLfloat difb,
GLfloat specr, GLfloat specg, GLfloat specb,
GLfloat shine);
void inline drawString (char *s);
void setOrthographicProjection();
void resetPerspectiveProjection();
// Variables globales ----------------------------------------------------------
bool lp;
GLfloat xrot=45.0f;
GLfloat yrot=15.0f;
GLfloat z =- 10.0f;
GLfloat lightAmbient[] = { 0.4f,0.4f,0.4f,0.0f };
GLfloat lightDiffuse[] = { 1.0f,0.0f,0.0f,1.0f };
GLfloat lightSpecular[]= {1.0, 1.0, 1.0, 0.0};
GLfloat lightPosition[] = {0.0f, 40.0f, 0.0f, 1.0f };
GLfloat lmodelAmbient[] = {0.2, 0.2, 0.2, 1.0};
GLfloat localView[] = {0.0};
GLfloat fogColor[4]= {0.5f, 0.5f, 0.5f, 1.0f};
GLfloat spotDirection[] = { 0.0, -1.0, 0.0 };
TextureImage texture[10];
char *textureName[]={"crate1.tga","crate2.tga","crate3.tga","crate4.tga","crate5.tga"};
int cambiaTextura = 3;
static char label[100];
int w,h;
static int frame=0, timer = 0, timebase=0;
float fps;
float lpos[4] = { 0.0, 5.0, 0.0, 0.0};
// InitGL -------------------------------------------------------------------
GLvoid initGL(GLvoid)
{
loadGLTextures(); // Carga las texturas
glEnable(GL_TEXTURE_2D); // Habilita el mapeo de texturas
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClearDepth(1.0);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glDepthMask(GL_TRUE);
glEnable(GL_AUTO_NORMAL);
glEnable(GL_NORMALIZE);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmbient );
glLightfv(GL_LIGHT0, GL_SPECULAR, lightSpecular);
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDiffuse );
//glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 2.0);
//glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 1.0);
//glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.001);
//glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 0.2);
//glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 45.0);
//glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, spotDirection);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodelAmbient);
glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, localView);
glEnable(GL_FOG);
glFogfv(GL_FOG_COLOR,fogColor);
glFogf(GL_FOG_DENSITY,0.03f);
glFogi(GL_FOG_MODE, GL_EXP);
glFogf(GL_FOG_START, 0.0f);
glFogf(GL_FOG_END, 150.f);
}
// DrawGLScene -----------------------------------------------------
GLvoid display(GLvoid)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0.0f,0.0f,z);
glRotatef(xrot,1.0f,0.0f,0.0f);
glRotatef(yrot,0.0f,1.0f,0.0f);
glLightfv(GL_LIGHT0,GL_POSITION,lpos);
glPushMatrix();
glColor3f(1.0,1.0,1.0);
glTranslatef(lpos[0],lpos[1],lpos[2]);
glutWireSphere(0.2f,10,10);
glPopMatrix();
glColor3f(1,1,1);
glBindTexture(GL_TEXTURE_2D, texture[cambiaTextura].texID);
glPushMatrix();
glRotatef(12,0,1,0);
glBegin(GL_QUADS);
// Front Face
glNormal3f( 0.0f, 0.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
// Back Face
glNormal3f( 0.0f, 0.0f,-1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
// Top Face
glNormal3f( 0.0f, 1.0f, 0.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
// Bottom Face
glNormal3f( 0.0f,-1.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
// Right face
glNormal3f( 1.0f, 0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
// Left Face
glNormal3f(-1.0f, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslatef(-2.5,0.0,0.0);
glRotatef(67,0,1,0);
glBegin(GL_QUADS);
// Front Face
glNormal3f( 0.0f, 0.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
// Back Face
glNormal3f( 0.0f, 0.0f,-1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
// Top Face
glNormal3f( 0.0f, 1.0f, 0.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
// Bottom Face
glNormal3f( 0.0f,-1.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
// Right face
glNormal3f( 1.0f, 0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
// Left Face
glNormal3f(-1.0f, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslatef(2.5,0.0,0.0);
glRotatef(95,0,-1,0);
glBegin(GL_QUADS);
// Front Face
glNormal3f( 0.0f, 0.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
// Back Face
glNormal3f( 0.0f, 0.0f,-1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
// Top Face
glNormal3f( 0.0f, 1.0f, 0.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
// Bottom Face
glNormal3f( 0.0f,-1.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
// Right face
glNormal3f( 1.0f, 0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
// Left Face
glNormal3f(-1.0f, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glEnd();
glPopMatrix();
glPushMatrix();
glRotatef(35,0,1,0);
glTranslatef(0.0,1.8,0.0);
glScalef(0.8,0.8,0.8);
glBindTexture(GL_TEXTURE_2D, texture[6].texID);
glBegin(GL_QUADS);
// Front Face
glNormal3f( 0.0f, 0.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glEnd();
glBindTexture(GL_TEXTURE_2D, texture[8].texID);
glBegin(GL_QUADS);
// Top Face
glNormal3f( 0.0f, 1.0f, 0.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
// Bottom Face
glNormal3f( 0.0f,-1.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glEnd();
glBindTexture(GL_TEXTURE_2D, texture[7].texID);
glBegin(GL_QUADS);
// Back Face
glNormal3f( 0.0f, 0.0f,-1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
// Right face
glNormal3f( 1.0f, 0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
// Left Face
glNormal3f(-1.0f, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glEnd();
glPopMatrix();
glBindTexture(GL_TEXTURE_2D, texture[5].texID);
glColor3f(0.4,0.4,0.4);
glBegin(GL_QUADS);
glNormal3f( 0.0f, 1.0f, 0.0f);
glTexCoord2f(0.0, 1.0); glVertex3f(-5.0, -1.0, -5.0);
glTexCoord2f(0.0, 0.0); glVertex3f(-5.0, -1.0, 5.0);
glTexCoord2f(1.0, 0.0); glVertex3f(5.0, -1.0, 5.0);
glTexCoord2f(1.0, 1.0); glVertex3f(5.0, -1.0, -5.0);
glEnd();
glBindTexture(GL_TEXTURE_2D, texture[9].texID);
glBegin(GL_QUADS);
glNormal3f( 0.0f,0.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-5.0f, -1.0f, -5.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 5.0f, -1.0f, -5.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 5.0f, 6.0f, -5.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-5.0f, 6.0f, -5.0f);
glEnd();
glBegin(GL_QUADS);
glNormal3f( 0.0f,0.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( -5.0f, 6.0f, 5.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(5.0f, 6.0f, 5.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(5.0f, -1.0f, 5.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( -5.0f, -1.0f, 5.0f);
glEnd();
glBegin(GL_QUADS);
// Bottom Face
glNormal3f( -1.0f,0.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(5.0f, 6.0f, 5.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 5.0f, 6.0f, -5.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 5.0f, -1.0f, -5.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(5.0f, -1.0f, 5.0f);
glEnd();
glBegin(GL_QUADS);
// Bottom Face
glNormal3f( 1.0f,0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-5.0f, -1.0f, 5.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( -5.0f, -1.0f, -5.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( -5.0f, 6.0f, -5.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-5.0f, 6.0f, 5.0f);
glEnd();
setOrthographicProjection();
glPushMatrix();
glPushAttrib( GL_LIGHTING_BIT );
glPushAttrib( GL_TEXTURE_BIT );
glDisable(GL_TEXTURE_2D);
glDisable( GL_LIGHTING );
glLoadIdentity();
glColor3f(1.0f,0.0f,0.0f);
sprintf(label,"FPS: %5.2f",fps);
glRasterPos2f(30.0,30.0);
glColor3f(1.0f,1.0f,1.0f);
drawString (label);
glRasterPos2f(30.0,50.0);
drawString ("Controles");
glRasterPos2f(30.0,70.0);
drawString ("Iluminacion on/off: b");
glRasterPos2f(30.0,85.0);
drawString ("Cambio de texturas: clic izquierdo");
glRasterPos2f(30.0,100.0);
drawString ("Zoom in: w");
glRasterPos2f(30.0,115.0);
drawString ("Zoom out: s");
glPopAttrib();
glPopAttrib();
glPopMatrix();
resetPerspectiveProjection();
glutSwapBuffers();
glFlush();
}
// ReSizeGLScene ------------------------------------------------------------
void resize( int width , int height )
{
if (height==0)
{
height=1;
}
w=width;
h=height;
glViewport(0,0,width,height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,150.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
// Keyboard --------------------------------------------------------------
GLvoid keyboard(unsigned char Key, int x, int y)
{
#pragma unused (x, y)
switch(Key)
{
case 'b':
if (!lp)
{
lp = true;
glEnable(GL_LIGHTING);
}
else
{
lp = false;
glDisable(GL_LIGHTING);
}
break;
case 'w':
z+=2.0f;
break;
case 's':
z -= 2.0f;
break;
case 'q':
xrot -= 3.0f;
break;
case 'e':
xrot += 3.0f;
break;
case 'a':
yrot += 3.0f;
break;
case 'd':
yrot -= 3.0f;
break;
default:
break;
}
if (Key == 'i')
lpos[2] += 0.2f;
if (Key == 'k')
lpos[2] -= 0.2f;
if (Key == 'l')
lpos[0] += 0.2f;
if (Key == 'j')
lpos[0] -= 0.2f;
if (Key == 'u')
lpos[1] += 0.2f;
if (Key == 'o')
lpos[1] -= 0.2f;
glutPostRedisplay();
}
//Funcion callback para manejar eventos con el mouse
GLvoid mouse(int button,int state,int x,int y)
{
if(state == GLUT_DOWN)
{
switch(button)
{
case GLUT_LEFT_BUTTON:
if(cambiaTextura < 4)
cambiaTextura++;
else
cambiaTextura = 0;
break;
case GLUT_RIGHT_BUTTON:
break;
default:
break;
}
}
glutPostRedisplay();
}
// Idle -------------------------------------------------------------------
GLvoid idle(GLvoid)
{
frame++;
timer = glutGet(GLUT_ELAPSED_TIME);
if (timer - timebase > 1000)
{
fps = frame*1000.0/(timer-timebase);
timebase = timer;
frame = 0;
}
display();
}
// Main ---------------------------------------------------------------------
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(kWindowWidth, kWindowHeight);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
initGL();
glutDisplayFunc(display);
glutReshapeFunc(resize);
glutIdleFunc(idle);
glutMouseFunc(mouse);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}
// LoadGLTextures -----------------------------------------------------------
GLvoid loadGLTextures(GLvoid)
{
//Se cargan las texturas
loadTGA(&texture[0], textureName[0]);
loadTGA(&texture[1], textureName[1]);
loadTGA(&texture[2], textureName[2]);
loadTGA(&texture[3], textureName[3]);
loadTGA(&texture[4], textureName[4]);
loadTGA(&texture[5], "piso3.tga");
loadTGA(&texture[6], "caja1.tga");
loadTGA(&texture[7], "caja2.tga");
loadTGA(&texture[8], "caja3.tga");
loadTGA(&texture[9], "muro3.tga");
// Se crean las texturas
glBindTexture(GL_TEXTURE_2D, texture[0].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[0].width, texture[0].height, GL_RGB, GL_UNSIGNED_BYTE, texture[0].imageData);
glBindTexture(GL_TEXTURE_2D, texture[1].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[1].width, texture[1].height, GL_RGB, GL_UNSIGNED_BYTE, texture[1].imageData);
glBindTexture(GL_TEXTURE_2D, texture[2].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[2].width, texture[2].height, GL_RGB, GL_UNSIGNED_BYTE, texture[2].imageData);
glBindTexture(GL_TEXTURE_2D, texture[3].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[3].width, texture[3].height, GL_RGB, GL_UNSIGNED_BYTE, texture[3].imageData);
glBindTexture(GL_TEXTURE_2D, texture[4].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[4].width, texture[4].height, GL_RGB, GL_UNSIGNED_BYTE, texture[4].imageData);
glBindTexture(GL_TEXTURE_2D, texture[5].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[5].width, texture[5].height, GL_RGB, GL_UNSIGNED_BYTE, texture[5].imageData);
glBindTexture(GL_TEXTURE_2D, texture[6].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[6].width, texture[6].height, GL_RGB, GL_UNSIGNED_BYTE, texture[6].imageData);
glBindTexture(GL_TEXTURE_2D, texture[7].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[7].width, texture[7].height, GL_RGB, GL_UNSIGNED_BYTE, texture[7].imageData);
glBindTexture(GL_TEXTURE_2D, texture[8].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[8].width, texture[8].height, GL_RGB, GL_UNSIGNED_BYTE, texture[8].imageData);
glBindTexture(GL_TEXTURE_2D, texture[9].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[9].width, texture[9].height, GL_RGB, GL_UNSIGNED_BYTE, texture[9].imageData);
}
/********************> LoadTGA() <*****/
bool loadTGA(TextureImage *texture, char *filename) // Loads A TGA File Into Memory
{
GLubyte TGAheader[12]={0,0,2,0,0,0,0,0,0,0,0,0}; // Uncompressed TGA Header
GLubyte TGAcompare[12]; // Used To Compare TGA Header
GLubyte header[6]; // First 6 Useful Bytes From The Header
GLuint bytesPerPixel; // Holds Number Of Bytes Per Pixel Used In The TGA File
GLuint imageSize; // Used To Store The Image Size When Setting Aside Ram
GLuint temp; // Temporary Variable
GLuint type=GL_RGBA; // Set The Default GL Mode To RBGA (32 BPP)
FILE *file = fopen(filename, "rb"); // Open The TGA File
if( file==NULL || // Does File Even Exist?
fread(TGAcompare,1,sizeof(TGAcompare),file)!=sizeof(TGAcompare) || // Are There 12 Bytes To Read?
memcmp(TGAheader,TGAcompare,sizeof(TGAheader))!=0 || // Does The Header Match What We Want?
fread(header,1,sizeof(header),file)!=sizeof(header)) // If So Read Next 6 Header Bytes
{
fclose(file); // If Anything Failed, Close The File
return false; // Return False
}
texture->width = header[1] * 256 + header[0]; // Determine The TGA Width (highbyte*256+lowbyte)
texture->height = header[3] * 256 + header[2]; // Determine The TGA Height (highbyte*256+lowbyte)
if( texture->width <=0 || // Is The Width Less Than Or Equal To Zero
texture->height <=0 || // Is The Height Less Than Or Equal To Zero
(header[4]!=24 && header[4]!=32)) // Is The TGA 24 or 32 Bit?
{
fclose(file); // If Anything Failed, Close The File
return false; // Return False
}
texture->bpp = header[4]; // Grab The TGA's Bits Per Pixel (24 or 32)
bytesPerPixel = texture->bpp/8; // Divide By 8 To Get The Bytes Per Pixel
imageSize = texture->width*texture->height*bytesPerPixel; // Calculate The Memory Required For The TGA Data
texture->imageData=(GLubyte *)malloc(imageSize); // Reserve Memory To Hold The TGA Data
if( texture->imageData==NULL || // Does The Storage Memory Exist?
fread(texture->imageData, 1, imageSize, file)!=imageSize) // Does The Image Size Match The Memory Reserved?
{
if(texture->imageData!=NULL) // Was Image Data Loaded
free(texture->imageData); // If So, Release The Image Data
fclose(file); // Close The File
return false; // Return False
}
for(GLuint i=0; i
{ // Swaps The 1st And 3rd Bytes ('R'ed and 'B'lue)
temp=texture->imageData[i]; // Temporarily Store The Value At Image Data 'i'
texture->imageData[i] = texture->imageData[i + 2]; // Set The 1st Byte To The Value Of The 3rd Byte
texture->imageData[i + 2] = temp; // Set The 3rd Byte To The Value In 'temp' (1st Byte Value)
}
fclose (file); // Close The File
if (texture[0].bpp==24) // Was The TGA 24 Bits
{
type=GL_RGB; // If So Set The 'type' To GL_RGB
}
// Build A Texture From The Data
// We're doing this in a different function in this tutorial
glGenTextures(1, &texture[0].texID); // Generate OpenGL texture IDs
return true; // Texture Building Went Ok, Return True
}
void setMaterial( GLfloat ambr, GLfloat ambg, GLfloat ambb,
GLfloat difr, GLfloat difg, GLfloat difb,
GLfloat specr, GLfloat specg, GLfloat specb,
GLfloat shine)
{
GLfloat mat[4];
mat[0] = ambr; mat[1] = ambg; mat[2] = ambb; mat[3] = 1.0;
glMaterialfv(GL_FRONT, GL_AMBIENT, mat);
mat[0] = difr; mat[1] = difg; mat[2] = difb;
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat);
mat[0] = specr; mat[1] = specg; mat[2] = specb;
glMaterialfv(GL_FRONT, GL_SPECULAR, mat);
glMaterialf(GL_FRONT, GL_SHININESS, shine * 128.0);
}
void inline drawString (char *s)
{
unsigned int i;
for (i = 0; i < strlen (s); i++)
glutBitmapCharacter (GLUT_BITMAP_HELVETICA_12, s[i]);
}
void setOrthographicProjection()
{
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, w, 0, h);
glScalef(1, -1, 1);
glTranslatef(0, -h, 0);
glMatrixMode(GL_MODELVIEW);
}
void resetPerspectiveProjection()
{
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
En computación gráfica, shading se refiere al proceso de alterar el color basado en el ángulo de incidencia de la luz y la distancia de la fuente de luz, lo anterior con el fin de producir efectos visuales parecidos a los que en la realidad se producen. El proceso de shading se lleva acabo durante el rendering.
2. ¿Qué es, como se declara y se utiliza en OpenGL/GLUT?
Una fuente de luz
Es el origen de donde provendrá la iluminación de nuestra escena en OpenGL. Para crear una fuente de luz primero se debe activar la iluminación en OpenGL esto se logra con la función glEnable(GL_LIGHTING) y después se debe activar una fuente de luz por separado con la posibilidad de tener hasta 8, esto con el comando glEnable(GL_LIGHTn) donde n es el índice de la luz que se quiere activar.
Un material
Es la forma en la que se va interactuar con la luz reflejando las diferentes componentes roja, verde y azul, en diferente intensidad.
Para declarar un material se utiliza la función:
void glMaterial{if}(GLenum face, GLenum pname, TYPE param);
En su primer parámetro recibe una bandera la cual indica que caras de nuestro objeto tendrán las características de nuestro material ya sean las caras frontales, las de atrás o todo el objeto, el siguiente parámetro es otra bandera que indica el tipo de atributo de nuestro material, ejemplo la componente difusa, la componente ambiental, el tercer parámetro es el color que tendrá ese atributo de nuestro material.
Una textura
En principio para trabajar con texturas se necesita poder cargar imágenes en el formato de nuestra elección. Ya que OpenGL no tiene implementado algún método para esto, se tiene que realizar esta tarea de manera independiente. Resuelto lo anterior se debe proceder a activar las texturas, esto se logra con glEnable(GL_TEXTURE_2D). Antes de poder asignar una textura a cualquier objeto es necesario que el objeto tenga asignadas sus propias coordenadas de textura. Después de cargar la imagen, se tiene que generar un identificador con el cual OpenGL hará referencia a dicha textura, esto se logra con la función void glGenTextures( GLsizei n, GLuint *texturas ). Con este identificador ahora podemos referenciar la textura para poder generarla y asignarle algunos atributos. Para generar la textura se utiliza glTexImage2D(), y glTexParameteri() para asignar algunos características.
3. ¿Cúales son los atributos y características que se pueden declarar en OpenGL/GLUT para manejo de?
Luces
Los principales atributos de una luz son la posición, la componente difusa que representa el color de la luz, la componente ambiental que es el color de la iluminación global, y la componente specular que es el color de la luz que será reflejada por los objetos.
Materiales
Las características de los materiales son la difusa que es el color mate del objeto, la componente ambiental que es la iluminación ambiental que afecta al color del objeto, la componente specular que será el color que reflejará y el brillo que representa la intensidad de la componente specular.
Texturas
En cuanto texturas algunos atributos referentes son los filtros que se utilizaran para tratar la imagen, texturas ambientales, texturas cúbicas, otro parámetro es el número de repeticiones de dicha textura, entre otros.
4. Escriba un programa donde:
Dibuje un cubo y asigne características de material que lo hagan verse como de madera:
Aplique una textura de madera al cubo (bitmap)
Aplique como textura su fotografía
El cambio de modo se hará con un clic de Mouse
#include
#include
#include
#include
#include
#include
#include
// Constantes -----------------------------------------------------------------
#define kWindowWidth 800
#define kWindowHeight 600
// Estructuras ----------------------------------------------------------------
typedef struct // Se crea una estructura
{
GLubyte *imageData; // Datos de la imagen
GLuint bpp; // Profundidad del color de la imagen en bits por pixel
GLuint width; // Ancho de la imagen
GLuint height; // Alto de la imagen
GLuint texID; // Numero identificador de la textura
} TextureImage; // Nombre de la estructura
// Prototipos -------------------------------------------------------
bool loadTGA(TextureImage *texture, char *filename);
GLvoid initGL(GLvoid);
GLvoid display(GLvoid);
GLvoid resize(int width, int height);
GLvoid mouse(int button,int state,int x,int y);
GLvoid idle(GLvoid);
GLvoid loadGLTextures(void);
GLvoid keyboard(unsigned char key, int x, int y);
void setMaterial( GLfloat ambr, GLfloat ambg, GLfloat ambb,
GLfloat difr, GLfloat difg, GLfloat difb,
GLfloat specr, GLfloat specg, GLfloat specb,
GLfloat shine);
void inline drawString (char *s);
void setOrthographicProjection();
void resetPerspectiveProjection();
// Variables globales ----------------------------------------------------------
bool lp;
GLfloat xrot=45.0f;
GLfloat yrot=15.0f;
GLfloat z =- 10.0f;
GLfloat lightAmbient[] = { 0.4f,0.4f,0.4f,0.0f };
GLfloat lightDiffuse[] = { 1.0f,0.0f,0.0f,1.0f };
GLfloat lightSpecular[]= {1.0, 1.0, 1.0, 0.0};
GLfloat lightPosition[] = {0.0f, 40.0f, 0.0f, 1.0f };
GLfloat lmodelAmbient[] = {0.2, 0.2, 0.2, 1.0};
GLfloat localView[] = {0.0};
GLfloat fogColor[4]= {0.5f, 0.5f, 0.5f, 1.0f};
GLfloat spotDirection[] = { 0.0, -1.0, 0.0 };
TextureImage texture[10];
char *textureName[]={"crate1.tga","crate2.tga","crate3.tga","crate4.tga","crate5.tga"};
int cambiaTextura = 3;
static char label[100];
int w,h;
static int frame=0, timer = 0, timebase=0;
float fps;
float lpos[4] = { 0.0, 5.0, 0.0, 0.0};
// InitGL -------------------------------------------------------------------
GLvoid initGL(GLvoid)
{
loadGLTextures(); // Carga las texturas
glEnable(GL_TEXTURE_2D); // Habilita el mapeo de texturas
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClearDepth(1.0);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glDepthMask(GL_TRUE);
glEnable(GL_AUTO_NORMAL);
glEnable(GL_NORMALIZE);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmbient );
glLightfv(GL_LIGHT0, GL_SPECULAR, lightSpecular);
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDiffuse );
//glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 2.0);
//glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 1.0);
//glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.001);
//glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 0.2);
//glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 45.0);
//glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, spotDirection);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodelAmbient);
glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, localView);
glEnable(GL_FOG);
glFogfv(GL_FOG_COLOR,fogColor);
glFogf(GL_FOG_DENSITY,0.03f);
glFogi(GL_FOG_MODE, GL_EXP);
glFogf(GL_FOG_START, 0.0f);
glFogf(GL_FOG_END, 150.f);
}
// DrawGLScene -----------------------------------------------------
GLvoid display(GLvoid)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0.0f,0.0f,z);
glRotatef(xrot,1.0f,0.0f,0.0f);
glRotatef(yrot,0.0f,1.0f,0.0f);
glLightfv(GL_LIGHT0,GL_POSITION,lpos);
glPushMatrix();
glColor3f(1.0,1.0,1.0);
glTranslatef(lpos[0],lpos[1],lpos[2]);
glutWireSphere(0.2f,10,10);
glPopMatrix();
glColor3f(1,1,1);
glBindTexture(GL_TEXTURE_2D, texture[cambiaTextura].texID);
glPushMatrix();
glRotatef(12,0,1,0);
glBegin(GL_QUADS);
// Front Face
glNormal3f( 0.0f, 0.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
// Back Face
glNormal3f( 0.0f, 0.0f,-1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
// Top Face
glNormal3f( 0.0f, 1.0f, 0.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
// Bottom Face
glNormal3f( 0.0f,-1.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
// Right face
glNormal3f( 1.0f, 0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
// Left Face
glNormal3f(-1.0f, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslatef(-2.5,0.0,0.0);
glRotatef(67,0,1,0);
glBegin(GL_QUADS);
// Front Face
glNormal3f( 0.0f, 0.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
// Back Face
glNormal3f( 0.0f, 0.0f,-1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
// Top Face
glNormal3f( 0.0f, 1.0f, 0.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
// Bottom Face
glNormal3f( 0.0f,-1.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
// Right face
glNormal3f( 1.0f, 0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
// Left Face
glNormal3f(-1.0f, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslatef(2.5,0.0,0.0);
glRotatef(95,0,-1,0);
glBegin(GL_QUADS);
// Front Face
glNormal3f( 0.0f, 0.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
// Back Face
glNormal3f( 0.0f, 0.0f,-1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
// Top Face
glNormal3f( 0.0f, 1.0f, 0.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
// Bottom Face
glNormal3f( 0.0f,-1.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
// Right face
glNormal3f( 1.0f, 0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
// Left Face
glNormal3f(-1.0f, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glEnd();
glPopMatrix();
glPushMatrix();
glRotatef(35,0,1,0);
glTranslatef(0.0,1.8,0.0);
glScalef(0.8,0.8,0.8);
glBindTexture(GL_TEXTURE_2D, texture[6].texID);
glBegin(GL_QUADS);
// Front Face
glNormal3f( 0.0f, 0.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glEnd();
glBindTexture(GL_TEXTURE_2D, texture[8].texID);
glBegin(GL_QUADS);
// Top Face
glNormal3f( 0.0f, 1.0f, 0.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
// Bottom Face
glNormal3f( 0.0f,-1.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glEnd();
glBindTexture(GL_TEXTURE_2D, texture[7].texID);
glBegin(GL_QUADS);
// Back Face
glNormal3f( 0.0f, 0.0f,-1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
// Right face
glNormal3f( 1.0f, 0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
// Left Face
glNormal3f(-1.0f, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glEnd();
glPopMatrix();
glBindTexture(GL_TEXTURE_2D, texture[5].texID);
glColor3f(0.4,0.4,0.4);
glBegin(GL_QUADS);
glNormal3f( 0.0f, 1.0f, 0.0f);
glTexCoord2f(0.0, 1.0); glVertex3f(-5.0, -1.0, -5.0);
glTexCoord2f(0.0, 0.0); glVertex3f(-5.0, -1.0, 5.0);
glTexCoord2f(1.0, 0.0); glVertex3f(5.0, -1.0, 5.0);
glTexCoord2f(1.0, 1.0); glVertex3f(5.0, -1.0, -5.0);
glEnd();
glBindTexture(GL_TEXTURE_2D, texture[9].texID);
glBegin(GL_QUADS);
glNormal3f( 0.0f,0.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-5.0f, -1.0f, -5.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 5.0f, -1.0f, -5.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 5.0f, 6.0f, -5.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-5.0f, 6.0f, -5.0f);
glEnd();
glBegin(GL_QUADS);
glNormal3f( 0.0f,0.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( -5.0f, 6.0f, 5.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(5.0f, 6.0f, 5.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(5.0f, -1.0f, 5.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( -5.0f, -1.0f, 5.0f);
glEnd();
glBegin(GL_QUADS);
// Bottom Face
glNormal3f( -1.0f,0.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(5.0f, 6.0f, 5.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 5.0f, 6.0f, -5.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 5.0f, -1.0f, -5.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(5.0f, -1.0f, 5.0f);
glEnd();
glBegin(GL_QUADS);
// Bottom Face
glNormal3f( 1.0f,0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-5.0f, -1.0f, 5.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( -5.0f, -1.0f, -5.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( -5.0f, 6.0f, -5.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-5.0f, 6.0f, 5.0f);
glEnd();
setOrthographicProjection();
glPushMatrix();
glPushAttrib( GL_LIGHTING_BIT );
glPushAttrib( GL_TEXTURE_BIT );
glDisable(GL_TEXTURE_2D);
glDisable( GL_LIGHTING );
glLoadIdentity();
glColor3f(1.0f,0.0f,0.0f);
sprintf(label,"FPS: %5.2f",fps);
glRasterPos2f(30.0,30.0);
glColor3f(1.0f,1.0f,1.0f);
drawString (label);
glRasterPos2f(30.0,50.0);
drawString ("Controles");
glRasterPos2f(30.0,70.0);
drawString ("Iluminacion on/off: b");
glRasterPos2f(30.0,85.0);
drawString ("Cambio de texturas: clic izquierdo");
glRasterPos2f(30.0,100.0);
drawString ("Zoom in: w");
glRasterPos2f(30.0,115.0);
drawString ("Zoom out: s");
glPopAttrib();
glPopAttrib();
glPopMatrix();
resetPerspectiveProjection();
glutSwapBuffers();
glFlush();
}
// ReSizeGLScene ------------------------------------------------------------
void resize( int width , int height )
{
if (height==0)
{
height=1;
}
w=width;
h=height;
glViewport(0,0,width,height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,150.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
// Keyboard --------------------------------------------------------------
GLvoid keyboard(unsigned char Key, int x, int y)
{
#pragma unused (x, y)
switch(Key)
{
case 'b':
if (!lp)
{
lp = true;
glEnable(GL_LIGHTING);
}
else
{
lp = false;
glDisable(GL_LIGHTING);
}
break;
case 'w':
z+=2.0f;
break;
case 's':
z -= 2.0f;
break;
case 'q':
xrot -= 3.0f;
break;
case 'e':
xrot += 3.0f;
break;
case 'a':
yrot += 3.0f;
break;
case 'd':
yrot -= 3.0f;
break;
default:
break;
}
if (Key == 'i')
lpos[2] += 0.2f;
if (Key == 'k')
lpos[2] -= 0.2f;
if (Key == 'l')
lpos[0] += 0.2f;
if (Key == 'j')
lpos[0] -= 0.2f;
if (Key == 'u')
lpos[1] += 0.2f;
if (Key == 'o')
lpos[1] -= 0.2f;
glutPostRedisplay();
}
//Funcion callback para manejar eventos con el mouse
GLvoid mouse(int button,int state,int x,int y)
{
if(state == GLUT_DOWN)
{
switch(button)
{
case GLUT_LEFT_BUTTON:
if(cambiaTextura < 4)
cambiaTextura++;
else
cambiaTextura = 0;
break;
case GLUT_RIGHT_BUTTON:
break;
default:
break;
}
}
glutPostRedisplay();
}
// Idle -------------------------------------------------------------------
GLvoid idle(GLvoid)
{
frame++;
timer = glutGet(GLUT_ELAPSED_TIME);
if (timer - timebase > 1000)
{
fps = frame*1000.0/(timer-timebase);
timebase = timer;
frame = 0;
}
display();
}
// Main ---------------------------------------------------------------------
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(kWindowWidth, kWindowHeight);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
initGL();
glutDisplayFunc(display);
glutReshapeFunc(resize);
glutIdleFunc(idle);
glutMouseFunc(mouse);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}
// LoadGLTextures -----------------------------------------------------------
GLvoid loadGLTextures(GLvoid)
{
//Se cargan las texturas
loadTGA(&texture[0], textureName[0]);
loadTGA(&texture[1], textureName[1]);
loadTGA(&texture[2], textureName[2]);
loadTGA(&texture[3], textureName[3]);
loadTGA(&texture[4], textureName[4]);
loadTGA(&texture[5], "piso3.tga");
loadTGA(&texture[6], "caja1.tga");
loadTGA(&texture[7], "caja2.tga");
loadTGA(&texture[8], "caja3.tga");
loadTGA(&texture[9], "muro3.tga");
// Se crean las texturas
glBindTexture(GL_TEXTURE_2D, texture[0].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[0].width, texture[0].height, GL_RGB, GL_UNSIGNED_BYTE, texture[0].imageData);
glBindTexture(GL_TEXTURE_2D, texture[1].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[1].width, texture[1].height, GL_RGB, GL_UNSIGNED_BYTE, texture[1].imageData);
glBindTexture(GL_TEXTURE_2D, texture[2].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[2].width, texture[2].height, GL_RGB, GL_UNSIGNED_BYTE, texture[2].imageData);
glBindTexture(GL_TEXTURE_2D, texture[3].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[3].width, texture[3].height, GL_RGB, GL_UNSIGNED_BYTE, texture[3].imageData);
glBindTexture(GL_TEXTURE_2D, texture[4].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[4].width, texture[4].height, GL_RGB, GL_UNSIGNED_BYTE, texture[4].imageData);
glBindTexture(GL_TEXTURE_2D, texture[5].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[5].width, texture[5].height, GL_RGB, GL_UNSIGNED_BYTE, texture[5].imageData);
glBindTexture(GL_TEXTURE_2D, texture[6].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[6].width, texture[6].height, GL_RGB, GL_UNSIGNED_BYTE, texture[6].imageData);
glBindTexture(GL_TEXTURE_2D, texture[7].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[7].width, texture[7].height, GL_RGB, GL_UNSIGNED_BYTE, texture[7].imageData);
glBindTexture(GL_TEXTURE_2D, texture[8].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[8].width, texture[8].height, GL_RGB, GL_UNSIGNED_BYTE, texture[8].imageData);
glBindTexture(GL_TEXTURE_2D, texture[9].texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texture[9].width, texture[9].height, GL_RGB, GL_UNSIGNED_BYTE, texture[9].imageData);
}
/********************> LoadTGA() <*****/
bool loadTGA(TextureImage *texture, char *filename) // Loads A TGA File Into Memory
{
GLubyte TGAheader[12]={0,0,2,0,0,0,0,0,0,0,0,0}; // Uncompressed TGA Header
GLubyte TGAcompare[12]; // Used To Compare TGA Header
GLubyte header[6]; // First 6 Useful Bytes From The Header
GLuint bytesPerPixel; // Holds Number Of Bytes Per Pixel Used In The TGA File
GLuint imageSize; // Used To Store The Image Size When Setting Aside Ram
GLuint temp; // Temporary Variable
GLuint type=GL_RGBA; // Set The Default GL Mode To RBGA (32 BPP)
FILE *file = fopen(filename, "rb"); // Open The TGA File
if( file==NULL || // Does File Even Exist?
fread(TGAcompare,1,sizeof(TGAcompare),file)!=sizeof(TGAcompare) || // Are There 12 Bytes To Read?
memcmp(TGAheader,TGAcompare,sizeof(TGAheader))!=0 || // Does The Header Match What We Want?
fread(header,1,sizeof(header),file)!=sizeof(header)) // If So Read Next 6 Header Bytes
{
fclose(file); // If Anything Failed, Close The File
return false; // Return False
}
texture->width = header[1] * 256 + header[0]; // Determine The TGA Width (highbyte*256+lowbyte)
texture->height = header[3] * 256 + header[2]; // Determine The TGA Height (highbyte*256+lowbyte)
if( texture->width <=0 || // Is The Width Less Than Or Equal To Zero
texture->height <=0 || // Is The Height Less Than Or Equal To Zero
(header[4]!=24 && header[4]!=32)) // Is The TGA 24 or 32 Bit?
{
fclose(file); // If Anything Failed, Close The File
return false; // Return False
}
texture->bpp = header[4]; // Grab The TGA's Bits Per Pixel (24 or 32)
bytesPerPixel = texture->bpp/8; // Divide By 8 To Get The Bytes Per Pixel
imageSize = texture->width*texture->height*bytesPerPixel; // Calculate The Memory Required For The TGA Data
texture->imageData=(GLubyte *)malloc(imageSize); // Reserve Memory To Hold The TGA Data
if( texture->imageData==NULL || // Does The Storage Memory Exist?
fread(texture->imageData, 1, imageSize, file)!=imageSize) // Does The Image Size Match The Memory Reserved?
{
if(texture->imageData!=NULL) // Was Image Data Loaded
free(texture->imageData); // If So, Release The Image Data
fclose(file); // Close The File
return false; // Return False
}
for(GLuint i=0; i
{ // Swaps The 1st And 3rd Bytes ('R'ed and 'B'lue)
temp=texture->imageData[i]; // Temporarily Store The Value At Image Data 'i'
texture->imageData[i] = texture->imageData[i + 2]; // Set The 1st Byte To The Value Of The 3rd Byte
texture->imageData[i + 2] = temp; // Set The 3rd Byte To The Value In 'temp' (1st Byte Value)
}
fclose (file); // Close The File
if (texture[0].bpp==24) // Was The TGA 24 Bits
{
type=GL_RGB; // If So Set The 'type' To GL_RGB
}
// Build A Texture From The Data
// We're doing this in a different function in this tutorial
glGenTextures(1, &texture[0].texID); // Generate OpenGL texture IDs
return true; // Texture Building Went Ok, Return True
}
void setMaterial( GLfloat ambr, GLfloat ambg, GLfloat ambb,
GLfloat difr, GLfloat difg, GLfloat difb,
GLfloat specr, GLfloat specg, GLfloat specb,
GLfloat shine)
{
GLfloat mat[4];
mat[0] = ambr; mat[1] = ambg; mat[2] = ambb; mat[3] = 1.0;
glMaterialfv(GL_FRONT, GL_AMBIENT, mat);
mat[0] = difr; mat[1] = difg; mat[2] = difb;
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat);
mat[0] = specr; mat[1] = specg; mat[2] = specb;
glMaterialfv(GL_FRONT, GL_SPECULAR, mat);
glMaterialf(GL_FRONT, GL_SHININESS, shine * 128.0);
}
void inline drawString (char *s)
{
unsigned int i;
for (i = 0; i < strlen (s); i++)
glutBitmapCharacter (GLUT_BITMAP_HELVETICA_12, s[i]);
}
void setOrthographicProjection()
{
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, w, 0, h);
glScalef(1, -1, 1);
glTranslatef(0, -h, 0);
glMatrixMode(GL_MODELVIEW);
}
void resetPerspectiveProjection()
{
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
martes, 2 de octubre de 2007
PRACTICA 5
1. ¿Qué es el diseño orientado a eventos?
Es cuando debido a una acción o evento que suceda dentro del programa en tiempo real otras acciones o eventos responden, es decir, es una reacción del programa a sucesos dentro de él, ya sea debido al usuario o a sí mismo.
2. ¿Qué utilidad tiene el manejo de eventos en el desarrollo de aplicaciones gráficas?
Es la base de estas aplicaciones porque en su mayoría lo que hacen estos programas es responder a acciones del usuario como por ejemplo cuando hace un clic o cuando teclea algo o cuando usa un pad. Es la forma en la que un sistema puede "interactuar" con el usuario.
3. Programa que
- Al hacer un clic dibuje un punto en las coordenadas donde se hizo clic
- Cada 2 puntos dibujar una linea
- Cada 3 puntos dibujar un triángulo
- Cada 4 puntos dibujar un cuadrilatero
- Cada 5 puntos dibujar un poligono
- Con el boton derecho la cuenta de puntos vuelve a 0
- Con el boton de en medio limpiar la pantalla
#include "GL/glut.h"
int mousex[100],mousey[100],contador=0,puntos=0;
void Primitivas(void)
{
if(puntos==1)
{
glPointSize(2);
glColor3f(0.5,0.5,0.5);
glBegin(GL_POINTS);
glVertex2i(mousex[contador-1],mousey[contador-1]);
glEnd();
glFlush();
}
if(puntos==2)
{
glColor3f(0.5,0.5,0.5);
glBegin(GL_LINES);
glVertex2i(mousex[contador-2],mousey[contador-2]);
glVertex2i(mousex[contador-1],mousey[contador-1]);
glEnd();
glFlush();
}
if(puntos==3)
{
glColor3f(0.5,0.5,0.5);
glBegin(GL_TRIANGLES);
glVertex2i(mousex[contador-3],mousey[contador-3]);
glVertex2i(mousex[contador-2],mousey[contador-2]);
glVertex2i(mousex[contador-1],mousey[contador-1]);
glEnd();
glFlush();
}
if(puntos==4)
{
glColor3f(0.5,0.5,0.5);
glBegin(GL_QUADS);
glVertex2i(mousex[contador-4],mousey[contador-4]);
glVertex2i(mousex[contador-3],mousey[contador-3]);
glVertex2i(mousex[contador-2],mousey[contador-2]);
glVertex2i(mousex[contador-1],mousey[contador-1]);
glEnd();
glFlush();
}
if(puntos==5)
{
glColor3f(0.5,0.5,0.5);
glBegin(GL_POLYGON);
glVertex2i(mousex[contador-5],mousey[contador-5]);
glVertex2i(mousex[contador-4],mousey[contador-4]);
glVertex2i(mousex[contador-3],mousey[contador-3]);
glVertex2i(mousex[contador-2],mousey[contador-2]);
glVertex2i(mousex[contador-1],mousey[contador-1]);
glEnd();
glFlush();
}
}
void Escena(void)
{
glClearColor(1.0,1.0,1.0,0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0,600,620,0);
glFlush();
}
void BotonApretado(int boton,int estado,int x,int y)
{
if(estado == GLUT_DOWN)
{
switch(boton)
{
case GLUT_LEFT_BUTTON:
mousex[contador]=x;
mousey[contador]=y;
contador++;
puntos++;
Primitivas();
break;
case GLUT_RIGHT_BUTTON:
puntos=0;
break;
case GLUT_MIDDLE_BUTTON:
Escena();
puntos=0;
contador=0;
break;
default:
break;
}
}
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(600,620);
glutInitWindowPosition(0, 0);
glutCreateWindow("Cadenas Dibujadas");
glutDisplayFunc(Escena);
glutMouseFunc (BotonApretado);
glutMainLoop();
return 0;
}
Es cuando debido a una acción o evento que suceda dentro del programa en tiempo real otras acciones o eventos responden, es decir, es una reacción del programa a sucesos dentro de él, ya sea debido al usuario o a sí mismo.
2. ¿Qué utilidad tiene el manejo de eventos en el desarrollo de aplicaciones gráficas?
Es la base de estas aplicaciones porque en su mayoría lo que hacen estos programas es responder a acciones del usuario como por ejemplo cuando hace un clic o cuando teclea algo o cuando usa un pad. Es la forma en la que un sistema puede "interactuar" con el usuario.
3. Programa que
- Al hacer un clic dibuje un punto en las coordenadas donde se hizo clic
- Cada 2 puntos dibujar una linea
- Cada 3 puntos dibujar un triángulo
- Cada 4 puntos dibujar un cuadrilatero
- Cada 5 puntos dibujar un poligono
- Con el boton derecho la cuenta de puntos vuelve a 0
- Con el boton de en medio limpiar la pantalla
#include "GL/glut.h"
int mousex[100],mousey[100],contador=0,puntos=0;
void Primitivas(void)
{
if(puntos==1)
{
glPointSize(2);
glColor3f(0.5,0.5,0.5);
glBegin(GL_POINTS);
glVertex2i(mousex[contador-1],mousey[contador-1]);
glEnd();
glFlush();
}
if(puntos==2)
{
glColor3f(0.5,0.5,0.5);
glBegin(GL_LINES);
glVertex2i(mousex[contador-2],mousey[contador-2]);
glVertex2i(mousex[contador-1],mousey[contador-1]);
glEnd();
glFlush();
}
if(puntos==3)
{
glColor3f(0.5,0.5,0.5);
glBegin(GL_TRIANGLES);
glVertex2i(mousex[contador-3],mousey[contador-3]);
glVertex2i(mousex[contador-2],mousey[contador-2]);
glVertex2i(mousex[contador-1],mousey[contador-1]);
glEnd();
glFlush();
}
if(puntos==4)
{
glColor3f(0.5,0.5,0.5);
glBegin(GL_QUADS);
glVertex2i(mousex[contador-4],mousey[contador-4]);
glVertex2i(mousex[contador-3],mousey[contador-3]);
glVertex2i(mousex[contador-2],mousey[contador-2]);
glVertex2i(mousex[contador-1],mousey[contador-1]);
glEnd();
glFlush();
}
if(puntos==5)
{
glColor3f(0.5,0.5,0.5);
glBegin(GL_POLYGON);
glVertex2i(mousex[contador-5],mousey[contador-5]);
glVertex2i(mousex[contador-4],mousey[contador-4]);
glVertex2i(mousex[contador-3],mousey[contador-3]);
glVertex2i(mousex[contador-2],mousey[contador-2]);
glVertex2i(mousex[contador-1],mousey[contador-1]);
glEnd();
glFlush();
}
}
void Escena(void)
{
glClearColor(1.0,1.0,1.0,0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0,600,620,0);
glFlush();
}
void BotonApretado(int boton,int estado,int x,int y)
{
if(estado == GLUT_DOWN)
{
switch(boton)
{
case GLUT_LEFT_BUTTON:
mousex[contador]=x;
mousey[contador]=y;
contador++;
puntos++;
Primitivas();
break;
case GLUT_RIGHT_BUTTON:
puntos=0;
break;
case GLUT_MIDDLE_BUTTON:
Escena();
puntos=0;
contador=0;
break;
default:
break;
}
}
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(600,620);
glutInitWindowPosition(0, 0);
glutCreateWindow("Cadenas Dibujadas");
glutDisplayFunc(Escena);
glutMouseFunc (BotonApretado);
glutMainLoop();
return 0;
}
Suscribirse a:
Entradas (Atom)