Circulo de Bresenham

Implementar el algoritmo de Bresenham en OpenGL, marcando cada octante de diferente color. Añadir el círculo que están aproximando para comparar los resultados proporcionados por el algoritmo.Código

Previo Practica 7

Previo práctica 7



1.- ¿Qué es "shading" (sombreado) en términos de computacion gráfica?
En computación grafica "Shading" se refiere al proceso de alterar el color basado en el angulo y la distancia en que una fuente de luz reside en un objeto, creando un efecto realista.

2.- ¿Qué es y cómo se declara y usa en OpenGL/Glut

-Una fuente de luz
Proporciona una fuente de luz a nuestra escena para iluminarla
Se necesitan declarar la posisión componentes e intensidad de las luces declaradas como sigue:
glEnable(GL_LIGHTING); //Habilita luces
glDepthFunc(GL_LESS); //Tipo de Pruebas de profundidad
glEnable(GL_DEPTH_TEST); //Habilita Pueba de Profundidad
glFrontFace(GL_CCW); //Cara posterior de poligonos sentido contrahorario
GLfloat ambientLight[] = { 0.05, 0.05, 0.05, 1.0 };
GLfloat diffuseLight[] = { 0.7, 0.7, 0.7, 1.0 };
GLfloat specularLight[] = { 0.7, 0.7, 0.7, 1.0 };
glLightfv( GL_LIGHT0, GL_AMBIENT, ambientLight );
glLightfv( GL_LIGHT0, GL_DIFFUSE, diffuseLight );
glLightfv( GL_LIGHT0, GL_SPECULAR, specularLight );
glEnable( GL_LIGHT0 );//Habilita luz 0

-Un material
Es la reacción que va a tener nuestra materia en la escena hacia la luz
Se requiere declarar cual va a ser el comportamiento de dicho material con respecto a la luz como sigue:
float tKa[]= {X.xx,X.xx,X.xx,X.xx};
float tKd[]= {X.xx,X.xx,X.xx,X.xx};
float tKs[]= {X.xx,X.xx,X.xx,X.xx};
glMaterialfv(GL_FRONT, GL_AMBIENT, tKa);//Refracción de luz ambiente
glMaterialfv(GL_FRONT, GL_DIFFUSE, tKd);//Refracción de luz difusa
glMaterialfv(GL_FRONT, GL_SPECULAR, tKs);//Refracción de luz especular
glMaterialf (GL_FRONT, GL_SHININESS, int);//Brillo valor entero entre 0 y 128

-Una textura
Cubrir un poligono con alteraciones podria resultar muy costoso al procesador, hay casos en los que no es tan necesario hacer alteraciones dado que estas pueden ser representadas por imagenes, es como envolver una caja con papel de regalo, la caja sigue siendo la misma, pero el adorno fué mas economico que hacerle un grabado al cartón.
Se necesita un cargador de texturas para abrir un archivo de imagen, segun el tipo de archivo que queremos abrir es el tipo de cargador que necesitamos, esto coloca un apuntador a imagen y proseguimos a asociar los vertices de esa imagen a un plano como sigue en el ejemplo, en este caso yo utilice el cargadór de imagenes bmp de Chris Backhouse, bajo la licencia GNU:

BMPLoad("texturas/LABS.bmp",bmp);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D,0,3,bmp.width,bmp.height,0,
GL_RGB,GL_UNSIGNED_BYTE,bmp.bytes);
glBegin(GL_QUADS);
glNormal3f(0.0,-1.0,0.0);
glTexCoord2f(1.0,0.0); glVertex3f(0.5,-0.5,-0.5);
glTexCoord2f(0.0,0.0); glVertex3f(-0.5,-0.5,-0.5);
glTexCoord2f(0.0,1.0); glVertex3f(-0.5,-0.5,0.5);
glTexCoord2f(1.0,1.0); glVertex3f(0.5,-0.5,0.5);
glEnd();


3.- ¿Cuáles son los atributos/caracteristicas que se pueden declarar en Open/GLUT para manejo de:

-Luces
Las caracteristicas expresadas arriba, el tipo de luz ambiente, especular o difusa.
-Materiales
La manera en la que va a reflejar la luz recibida, de que manera debe de ser interpretada.
-Texturas
La forma de aplicar el material al poligono donde se encuentre pegado, puede ser modular, reemplazar, calcomania o fundido.

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 click del mouse

void CuboDePractica (void){
if (practica.cambiaCubo >= 3)
practica.cambiaCubo = 0;
printf("cambiacubo: %d\n",practica.cambiaCubo);
Material(0);
BMPClass bmp;

if (practica.cambiaCubo == 0){
Material (13);
glDisable(GL_TEXTURE_2D);
}
if (practica.cambiaCubo == 1){
BMPLoad("texturas/madera.bmp",bmp);
glEnable(GL_TEXTURE_2D);//se activa el mapeado de texturas
}
if (practica.cambiaCubo == 2){
glEnable(GL_TEXTURE_2D);//se activa el mapeado de texturas
}
glPushMatrix();//Despliegue del cubo con imagenes
if (practica.cambiaCubo == 2)
BMPLoad("texturas/yo1.bmp",bmp);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D,0,3,bmp.width,bmp.height,0,GL_RGB,GL_UNSIGNED_BYTE,bmp.bytes);
glBegin(GL_QUADS);
glNormal3f(0.0,0.0,1.0);
glTexCoord2f(1.0,1.0); glVertex3f(0.5,0.5,0.5);
glTexCoord2f(0.0,1.0); glVertex3f(-0.5,0.5,0.5);
glTexCoord2f(0.0,0.0); glVertex3f(-0.5,-0.5,0.5);
glTexCoord2f(1.0,0.0); glVertex3f(0.5,-0.5,0.5);
glEnd();
if (practica.cambiaCubo == 2)
BMPLoad("texturas/yo2.bmp",bmp);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D,0,3,bmp.width,bmp.height,0,GL_RGB,GL_UNSIGNED_BYTE,bmp.bytes);
glBegin(GL_QUADS);
glNormal3f(0.0,0.0,-1.0);
glTexCoord2f(1.0,1.0); glVertex3f(-0.5,0.5,-0.5);
glTexCoord2f(0.0,1.0); glVertex3f( 0.5,0.5,-0.5);
glTexCoord2f(0.0,0.0); glVertex3f(0.5,-0.5,-0.5);
glTexCoord2f(1.0,0.0); glVertex3f(-0.5,-0.5,-0.5);
glEnd();
if (practica.cambiaCubo == 2)
BMPLoad("texturas/yo3.bmp",bmp);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D,0,3,bmp.width,bmp.height,0,GL_RGB,GL_UNSIGNED_BYTE,bmp.bytes);
glBegin(GL_QUADS);
glNormal3f(-1.0,0.0,0.0);
glTexCoord2f(1.0,1.0); glVertex3f(-0.5,0.5,0.5);
glTexCoord2f(0.0,1.0); glVertex3f(-0.5,0.5,-0.5);
glTexCoord2f(0.0,0.0); glVertex3f(-0.5,-0.5,-0.5);
glTexCoord2f(1.0,0.0); glVertex3f(-0.5,-0.5,0.5);
glEnd();
if (practica.cambiaCubo == 2)
BMPLoad("texturas/yo4.bmp",bmp);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D,0,3,bmp.width,bmp.height,0,GL_RGB,GL_UNSIGNED_BYTE,bmp.bytes);
glBegin(GL_QUADS);
glNormal3f(1.0,0.0,0.0);
glTexCoord2f(0.0,1.0); glVertex3f(0.5,0.5,0.5);
glTexCoord2f(0.0,0.0); glVertex3f(0.5,-0.5,0.5);
glTexCoord2f(1.0,0.0); glVertex3f( 0.5,-0.5,-0.5);
glTexCoord2f(1.0,1.0); glVertex3f(0.5,0.5,-0.5);
glEnd();
if (practica.cambiaCubo == 2)
BMPLoad("texturas/yo5.bmp",bmp);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D,0,3,bmp.width,bmp.height,0,GL_RGB,GL_UNSIGNED_BYTE,bmp.bytes);
glBegin(GL_QUADS);
glNormal3f(0.0,1.0,0.0);
glTexCoord2f(0.0,1.0); glVertex3f(-0.5,0.5,-0.5);
glTexCoord2f(0.0,0.0); glVertex3f(-0.5,0.5,0.5);
glTexCoord2f(1.0,0.0); glVertex3f(0.5,0.5,0.5);
glTexCoord2f(1.0,1.0); glVertex3f( 0.5,0.5,-0.5);
glEnd();
if (practica.cambiaCubo == 2)
BMPLoad("texturas/LABS.bmp",bmp);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D,0,3,bmp.width,bmp.height,0,GL_RGB,GL_UNSIGNED_BYTE,bmp.bytes);
glBegin(GL_QUADS);
glNormal3f(0.0,-1.0,0.0);
glTexCoord2f(1.0,0.0); glVertex3f(0.5,-0.5,-0.5);
glTexCoord2f(0.0,0.0); glVertex3f(-0.5,-0.5,-0.5);
glTexCoord2f(0.0,1.0); glVertex3f(-0.5,-0.5,0.5);
glTexCoord2f(1.0,1.0); glVertex3f(0.5,-0.5,0.5);
glEnd();
glDisable(GL_TEXTURE_2D);
glPopMatrix();
glFlush();
}

Reporte Practica 6

Reporte práctica 6

1.- Escriba un programa que lea un archivo de texto plano (.txt) y lo transforme a caracteres
dibujados (stroke) y dibuje dicho texto en pantalla.

-El texto se debe mostrar con un efecto de deslizamiento (scroll) de abajo hacia arriba
(Estilo entrada de Star Wars). Usar el callback glutIdleFunc, glutSwapBuffers y el parámetro
GLUT_DOUBLE. Explique cómo y dónde se usan estas funciones y constante.



Archivos de texto:
texto.txt
archivo.txt

void leeArchivo (void){
FILE *f;
char c;
int i=1, a=0, b=0, d=0;
if (variable.tempo == 3)
f=fopen("texto.txt","r");
else
f=fopen("archivo.txt","r");
c=fgetc(f);
variable.temporal[0] = c;
while (c!=EOF){
c=fgetc(f);
variable.temporal[i] = c;
i++;
}
fclose(f);
variable.temporal[i-1] = '\0';
for (a=0;a<=19;a++)
for (b=0;b<=19;b++){
variable.buffer[a][b]=variable.temporal[d];
d++;
}
}

void imprimeCadenaStroke(float x, float y, float z, char *string) {
char *c;
glTranslatef( x, y, z);
for (c=string; *c != '\0'; c++) {
glutStrokeCharacter(GLUT_STROKE_MONO_ROMAN, *c);
}
}

glPushMatrix();
glRotatef(variable.reduce, 1,0,0);
glPushMatrix();
glColor3f( 0.0f, 1.0f, 0.0f);
glScalef ( 0.70f, 0.70f, 0.70f);
variable.tempo = 3;
leeArchivo();
glTranslatef( -1050, variable.transladatexto, 0.0);
glPushMatrix();
for (i=0;i<13;i++){
imprimeCadenaStroke ( 0, 0, 0,variable.buffer[i]);
glScalef ( variable.reduce, variable.reduce, 1.0);
glTranslatef(-2095,120,0);
glScalef ( variable.reduce, variable.reduce, 1.0);
}
glPopMatrix();
glPopMatrix();
glPopMatrix();
break;

2.- Escriba un programa que, dada una cadena de entrada, dibuje en forma desordenada los caracteres en la
ventana y los vaya trasladando y ordenando hasta mostrar la cadena correcta.

Tareas 4 y 5

Tarea 4
En OpenGL: dibujar un robot, usando modelado jerárquico. El dibujo deberá ser similar al siguiente:

Puede ser en 2D o 3D, y preferentemente usar colores.

Tarea 5
Animar el robot que diseñaron en la tarea 4. Como sugerencias: Puede saludar a la cámara, caminar, bailar, dar marometas, responder a eventos como clicks, sentarse, etc.


El código es demaciado grande y lo subi a las direcciones:
http://wyrven.iespana.es/099036568.cpp y
http://wyrven.iespana.es/objetos.h

Cohen Sutherland

El Programa es muy grande y lo subí a

http://wyrven.iespana.es/Cohen-Sutherland.cpp

Previo Practica 6

1.- ¿Cómo se dibuja texto con GLUT?

Utilizando la función glutbitmapCharacter podemos pintar texto bidimencional en un ambiente tridimencionar que no podemos rotar o escalar, no tiene grosor y siempre estara orientado hacia el observador, esto presenta ciertas desventajas pero por otro lado no nos tenemos que preocupar por reorientar el texto cuando hacemos alguna transformación.

Utilizando la función glutStrokeCharacter podemos pintar texto que puede ser rotado, escalado o transladado.

¿Cambia el dibujo de texto en FreeGLUT y OpenGLUT? ¿Por qué?
Si, cambia pues OpenGLUT hereda un pequeño número de fuentes estándar de FreeGLUT y GLUT.

2.- Cómo funcionan y cuántos son los parametros de los comandos:

glutBitmapCharacter();
void glutBitmapCharacter(void *font, int character)

Parametros:

font - El nombre del font a usar
GLUT_BITMAP_8_BY_13
GLUT_BITMAP_9_BY_15
GLUT_BITMAP_TIMES_ROMAN_10
GLUT_BITMAP_TIMES_ROMAN_24
GLUT_BITMAP_HELVETICA_10
GLUT_BITMAP_HELVETICA_12
GLUT_BITMAP_HELVETICA_18
character - ASCII a imprimir (va entre comillas simples por ser un entero)

glutStrokeCharacter();
void glutStrokeCharacter(void *font, int character)

Parametros:

font - El nombre del font a usar
GLUT_STROKE_ROMAN
GLUT_STROKE_MONO_ROMAN
character - ASCII a imprimir (va entre comillas simples por ser un entero)

¿En que se diferencian?
stroke puede rotar, escalar o transladar el texto y bitmap no.

3.- Escriba un programa que dibuje su nombre y numero de cuenta en la pantalla.

imprimeCadenaBitmap (-95,0,0,"Alberto Bobadilla");
glColor3f( 0.0f, 1.0f, 0.0f);
glScalef( 0.15f, 0.15f, 0.15f);
imprimeCadenaStroke (0,0,0,"99036568");

void imprimeCadenaBitmap(float x, float y, float z, char *string) {
char *c;
glRasterPos3f( x, y, z);
for (c=string; *c != '\0'; c++) {
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, *c);
}
}
void imprimeCadenaStroke(float x, float y, float z, char *string) {
char *c;
glRasterPos3f( x, y, z);
for (c=string; *c != '\0'; c++) {
glutStrokeCharacter(GLUT_STROKE_MONO_ROMAN, *c);
}
}

Reporte Practica 5

1.- ¿Qué es diseño orientado a eventos?
Es el tipo de diseño que recibe entradas desde diferentes dispositivos provocando sucesos en el codigo.

2.- ¿Qué utilidad tiene el manejo de eventos en el desarrollo de aplicaciones gráficas?
Un ejemplo claro puede ser la programación de juegos de video en donde los eventos generan ciertas situaciones sobre los graficos para denotar un suceso en el programa.

3.- Escriba un programa en el cual:

- Al hacer click en la ventana se toman las coordenadas del mouse y se dibuja un punto.

- Cada dos puntos acumulados se dibuja una linea.

- Cada tres puntos acumulados se dubuja un triángulo.

- Cada cuatro puntos acumulados dibuja un cuadrilatero.

- Cada 5 o más puntos acumulados, dibuja un poligono.

- El botón izquierdo del mouse limpia la ventana.

OJO: checar la funcion glViewport para ajustar escalas dentro de la ventana.

Previo Practica 5

1.- Escriba una aplicacion que usando la libreria GLUT detecte que se ha realizado un click con el botón derecho del mouse sobre la ventana principal e imprima las coordenadas del mouse con la salida estándar.

-Cuando se haga click con el boton izquierdo, cierre la aplicación.

Nota: Usar glutMouseFunc();

void mouse (int button, int state, int x, int y){

switch (button){ //Left Button Clicked

case GLUT_LEFT_BUTTON:

switch (state){

case GLUT_DOWN: //Pressed

exit(0);

break;

}

break;

case GLUT_RIGHT_BUTTON:// Right Button Clicked

switch (state){

case GLUT_DOWN: // Pressed

printf ("Mouse Right Button Pressed on (%d,%d)(Down)...\n",x,y);

break;

case GLUT_UP: // Released

printf ("Mouse Left Button Released on (%d,%d)(Up)...\n",x,y);

break;

}

break;

}

glutPostRedisplay ();

}

2.- Escriba una aplicación que cada 5 segundos abra una nueva ventana y como titulo le

ponga el tiempo en el que se creó.

-Al apretar el botón izquierdo del mouse, para el contador.

-Al apretar el botón derecho reinicia el contador.

-Al apretar la tecla "ESC" cierra la aplicación.

#include

#include

#include

#include

#include

struct practicas{

int ancho, alto, x, y, PrevX, PrevY, ventana;

time_t comienzo, final;

char buffer[10];

float cont;

signed int bandera, RMB;

}variable;

void inicializa (void){

variable.ancho = 500;

variable.alto = 500;

variable.x=100;

variable.y=100;

variable.bandera=0;

variable.RMB=0;

variable.ventana=1;

}

void display(void){

glClearColor(0.0, 0.0, 0.0, 0.0);

glClear(GL_COLOR_BUFFER_BIT);

glLoadIdentity();

glFlush();

}

void reshape (int ancho, int alto){

if(ancho==0)

ancho=1;

glViewport(0, (GLsizei) 0, (GLsizei) ancho, (GLsizei) alto);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluPerspective(45.0f,(float)(ancho/((alto==0)?1:alto)),0.01f,500.0f);

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

}

void mouse (int button, int state, int x, int y){

variable.PrevX = x;

variable.PrevY = y;

switch (button){ //Left Button Clicked

case GLUT_LEFT_BUTTON:

switch (state){

case GLUT_DOWN: //Pressed

variable.bandera = 0;

break;

}

break;

case GLUT_MIDDLE_BUTTON:// Middle Button clicked

switch (state){

case GLUT_DOWN:// Pressed

exit(0);

break;

}

break;

case GLUT_RIGHT_BUTTON:// Right Button Clicked

switch (state){

case GLUT_DOWN: // Pressed

variable.bandera = 0;

variable.comienzo = time( NULL );

break;

}

break;

}

glutPostRedisplay ();

}

void TimerFunction(int valor){

if(variable.ventana<=10 && variable.bandera == 0){

variable.x=variable.x+50;

variable.y=variable.y+50;

glutInitWindowPosition(variable.x,variable.y);

variable.final = time( NULL );

variable.cont=difftime(variable.final, variable.comienzo);

printf( "Segundos desde el comienzo del programa: %f s\n", variable.cont);

sprintf(variable.buffer,"%.1f s\0",variable.cont);

glutCreateWindow(variable.buffer);

glutDisplayFunc(display);

glutReshapeFunc(reshape);

glutMouseFunc (mouse);

variable.ventana++;

}

glutPostRedisplay();

glutTimerFunc(5000,TimerFunction, 1);

}

int main(int argc, char **argv){

inicializa();

variable.comienzo = time( NULL );

printf( "Segundos desde el comienzo del programa: %f s\n", variable.cont);

sprintf(variable.buffer,"%.1f s\0",variable.cont);

glutInit (&argc, argv);

glutInitDisplayMode (GLUT_RGB);

glutInitWindowSize (variable.ancho, variable.alto);

glutInitWindowPosition (variable.x,variable.y);

glutCreateWindow (variable.buffer);

glutDisplayFunc (display);

glutReshapeFunc (reshape);

glutMouseFunc (mouse);

glutTimerFunc(5000, TimerFunction, 99036568);

glutMainLoop();

return 0;

}

Nota: Usar glutTimeFunc, glutMouseFunc y glutKeyboardFunc

3.- ¿Que comandos para manejo de eventos nos proporciona GLUT?

Describa cada uno de éstos.

glut________func();

glutKeyboardfunc()ñ

Maneja entradas de eventos desde teclado correspondientes al teclado normal y caracteres en el codico ASCII

glutSpecialfunc();

Maneja entradas de eventos desde teclado para caracteres especiales como las teclas de función flechas direccionales etc

glutMousefunc()ñ

Maneja entradas de eventos desde el raton para 3 botones.

Reporte Practica 4

1.- Describa las ventajas de construir de manera jerárquica escenas

Las ventajas que presenta el construir una escena de forma Jerárquica es que podemos modificar parte del escenario sin tener necesidad de escribir nuevo código para nuevos elementos. Simplemente se aplican nuevas transformaciones a elementos anteriores de manera que se reutiliza código.

2.- Escriba un programa que construya de manera jerárquica una escena en la que:

- Hayan 3 humanoides:

- 1 alto y flaco

- 1 normal

- 1 chaparro y regordete

- Cada uno se encuentre en el vértice de un triángulo equilátero coplanar con el plano XY

- En el centro del triángulo se encuentre un prisma de base cuadrada

- En la cima del prisma se encuentre "Cthulhu" (esfera con 8 brazos amorfos, con puntas en tenaza...)

void Rlyeh (void){

glPushMatrix();

//----Piso----//

glPushMatrix();

glColor3f( 0.0f, 0.0f, 1.0f);

glTranslatef( 0.0f,-10.0f, 0.0f);

glScalef ( 300.0f, 5.0f, 300.0f);

cubo();

glPopMatrix();

glPushMatrix();

glColor3f( 0.0f, 0.0f, 0.7f);

glTranslatef( 0.0f,-5.0f, 0.0f);

glScalef ( 280.0f, 4.0f, 280.0f);

cubo();

glPopMatrix();

//----Altar----//

glPushMatrix();

glColor3f( 1.0f, 1.0f, 1.0f);

glTranslatef( 0.0f, 25.0f, 0.0f);

glScalef ( 50.0f, 50.0f, 50.0f);

cubo3();

glPopMatrix();

//----Cthulhu----//

glPushMatrix();

glTranslatef( 1.0f, 110.0f, 1.0f);

glScalef ( 8.0f, 8.0f, 8.0f);

Cthulhu();

glPopMatrix();

//----Humanoide Alto----//

glPushMatrix();

glColor3f( variable.cr, variable.cg, variable.cb);

glRotatef(-45.0f, 0.0f, 1.0f, 0.0f);

glTranslatef( 0.0f, 50.0f,-80.0f);

glScalef ( 3.0f, 8.0f, 3.0f);

variable.ropa = 1;

hume(variable.c_piel[0], variable.c_piel[1], variable.c_piel[2], 3, variable.ropa, variable.m_arm, variable.m_finger);

glPopMatrix();

//----Humanoide Chaparro----//

glPushMatrix();

glColor3f( variable.cr, variable.cg, variable.cb);

glRotatef( 45.0f, 0.0f, 1.0f, 0.0f);

glTranslatef( 0.0f, 21.0f,-80.0f);

glScalef ( 5.0f, 3.0f, 5.0f);

hume(variable.c_piel[0], variable.c_piel[1], variable.c_piel[2], 2, variable.ropa, variable.m_arm, variable.m_finger);

glPopMatrix();

//----Humanoide Normal----//

glPushMatrix();

glRotatef( 180.0f, 0.0f, 1.0f, 0.0f);

glColor3f( variable.cr, variable.cg, variable.cb);

glTranslatef( 0.0f, 35.0f, -75.0f);

glScalef ( 5.0f, 5.0f, 5.0f);

hume(variable.c_piel[0], variable.c_piel[1], variable.c_piel[2], variable.cabeza, variable.ropa, variable.m_arm,variable.m_finger);

glPopMatrix();

glPopMatrix();

}

Previo 4

Previo 4.- Escenas y manejo de eventos

1. ¿Qué es una escena?

Es el conjunto de luces, cámaras, atributos y modelos asociados a un ambiente 3D.

2. ¿Cómo podemos definir cada escena jerárquicamente?

Es necesario ordenar los elementos de manera lógica por medio de la técnica grafo de escena. Se define la relación que existe entre varios objetos y se emplean transformaciones en común.

3. Describa el funcionamiento y parámetros de las siguientes funciones:

void glutSwapBuffers(void);

Los comandos son asignados al buffer secundario hasta que llamamos a esta función para que glut tome el contenido de dicho buffer lo pase al primario para dibujar.

void glutKeyboardFunc(void (*func)(unsigned char key, int x, int y));

Funcion que maneja los eventos del teclado para ASCII, sinembargo no toma los caracteres especiales.

void glutIdleFunc(void (*func)(void));

Esta function se llama automaticamente cuando detecta que el procesador no esta trabajando para hacer tareas en segundo plano.

4. ¿Qué es un double buffer? ¿Para que sirve?

Al tenerte una memoria secundaria de nuestra escena evitamos perdida en el refresco de pantalla. De esto se encarga el doublé buffer, en tener una copia de nuestra escena completa.

5. ¿Qué es una función callback (llamada a función)?

Es una función que se llama a si misma reiteradamente cuando detecta una entrada o la mandamos llamar para esperar un evento.

6. Escriba código que detecte un evento

void mouse (int button, int state, int x, int y){

switch (button){ //Left Button Clicked

case GLUT_LEFT_BUTTON:

switch (state){

case GLUT_DOWN: //Pressed

Ang=Ang+5;

mx=0;

my=1;

mz=0;

break;

case GLUT_UP:// Released

Ang=Ang+5;

mx=0;

my=1;

mz=0;

break;

}

break;

case GLUT_MIDDLE_BUTTON:// Middle Button clicked

switch (state){

case GLUT_DOWN:// Pressed

printf ("Mouse Middle Button Pressed (Down)...\n");

break;

case GLUT_UP:// Released

printf ("Mouse Middle Button Released (Up)...\n");

break;

}

break;

case GLUT_RIGHT_BUTTON:// Right Button Clicked

switch (state){

case GLUT_DOWN: // Pressed

Ang=Ang-5;

mx=0;

my=1;

mz=0;

break;

case GLUT_UP: // Released

Ang=Ang-5;

mx=0;

my=1;

mz=0;

break;

}

break;

}

glutPostRedisplay ();

}

void keyboard(unsigned char key, int x, int y){
switch (key) {
case 27:
exit(0);
break;
case 88:
case 120:
Ang=Ang+15;
mx=1;
my=0;
mz=0;
break;
case 89:
case 121:
Ang=Ang+15;
mx=0;
my=1;
mz=0;
break;
case 90:
case 122:
Ang=Ang+15;
mx=0;
my=0;
mz=1;
break;
case 66:
case 98:
cr=0;
cg=0;
cb=255;
bandera=1;
break;
case 71:
case 103:
cr=0;
cg=255;
cb=0;
bandera=1;
break;
case 82:
case 114:
cr=255;
cg=0;
cb=0;
bandera=1;
break;
case 48:
pinta=0;
break;
case 49:
pinta=1;
break;
case 50:
pinta=2;
break;
case 51:
pinta=3;
break;
case 52:
pinta=4;
break;
case 53:
pinta=5;
break;
case 54:
pinta=6;
break;
case 55:
pinta=7;
break;
case 56:
pinta=8;
break;
case 57:
pinta=9;
break;
}
glutPostRedisplay ();
}

Reporte practica 3

//Escriba el código para dibujar una mano.

void finger (float c_pielR,float c_pielG,float c_pielB,float m_finger){
glPushMatrix();
glPushMatrix();
glColor3f(c_pielR, c_pielG+0.03f, c_pielB+0.03f);
glScalef( 1.0f, 2.0f, 1.0f);
cubo();
glPopMatrix();
glTranslatef( 0.0f, 1.5f, 0.0f);
glRotatef ( (GLfloat) m_finger, -1.0f, 0.0f, 0.0f);
glTranslatef( 0.0f, 0.5f, 0.0f);
glPushMatrix();
glColor3f(c_pielR, c_pielG+0.08f, c_pielB+0.08f);
glScalef ( 1.0f, 2.0f, 1.0f);
cubo();
glPopMatrix();
glPushMatrix();
glTranslatef( 0.0f, 0.5f, 0.0f);
glRotatef ( (GLfloat) m_finger, -1.0f, 0.0f, 0.0f);
glTranslatef( 0.0f, 1.5f, 0.0f);
glColor3f(c_pielR, c_pielG+0.1f, c_pielB+0.1f);
glScalef ( 1.0f, 2.0f, 1.0f);
cubo();
glPopMatrix();
glPopMatrix();
}
void hand (float c_pielR,float c_pielG,float c_pielB,float m_finger){
glPushMatrix();
glPushMatrix();// Palma
glPushMatrix();
glColor3f(c_pielR, c_pielG-0.02f, c_pielB-0.02f);
glTranslatef( 0.0f, 3.5f, 0.0f);
glScalef ( 4.0f, 5.0f, 1.0f);
cubo();
glPopMatrix();
glPushMatrix();
glColor3f(c_pielR, c_pielG-0.02f, c_pielB-0.02f);
glTranslatef( 0.0f, 0.5f, 0.0f);
glScalef ( 2.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();
glPopMatrix();
glPushMatrix();// Dedo Indice
glTranslatef(-1.5f, 6.5f, 0.0f);
glRotatef( m_finger,-1.0f, 0.0f, 0.0f);
glTranslatef( 0.0f, 0.5f, 0.0f);
glScalef ( 0.7f, 1.0f, 0.7f);
finger(c_pielR, c_pielG, c_pielB, m_finger);
glPopMatrix();
glPushMatrix();// Dedo Medio
glTranslatef(-0.5f, 6.5f,-0.05f);
glRotatef( m_finger * variable.obsena,-1.0f, 0.0f, 0.0f);
glTranslatef( 0.0f, 0.5f, 0.0f);
glScalef ( 0.7f, 1.2f, 0.7f);
finger( c_pielR, c_pielG, c_pielB, m_finger * variable.obsena);
glPopMatrix();
glPushMatrix();// Dedo Anular
glTranslatef( 0.5f, 6.5f, 0.0f);
glRotatef( m_finger,-1.0f, 0.0f, 0.0f);
glTranslatef( 0.0f, 0.5f, 0.0f);
glScalef ( 0.7f, 1.0f, 0.7f);
finger( c_pielR, c_pielG, c_pielB, m_finger);
glPopMatrix();

glPushMatrix();// Dedo Menique
glTranslatef( 1.5f, 6.2f, 0.05f);
glRotatef( m_finger,-1.0f, 0.0f, 0.0f);
glTranslatef( 0.0f, 0.5f, 0.0f);
glScalef ( 0.7f, 0.7f, 0.7f);
finger( c_pielR, c_pielG, c_pielB, m_finger);
glPopMatrix();

glPushMatrix();// Dedo Pulgar
glTranslatef(-2.0f, 3.5f, 0.0f);
glRotatef( 45.0f,0.0f, 0.0f, 1.0f);
glScalef ( 1.0f, 0.4f, 1.0f);
finger(c_pielR, c_pielG, c_pielB, m_finger);
glPopMatrix();
glPopMatrix();
}

LABS - Feed

Probando el feeder.

Previo 1 Computación Gráfica

Previo

Open GL y Modelado geométrico

Investigue el uso parámetros y variantes de los comandos de open gl

glBegin()

glEnd()

Delimitan los vértices de una primitiva o grupo de primitivas. Begin es el comienzo y End el fin, los parámetros que reciben son: GL_POINTS, GL_LINES, GL_LINE_STRIP, GL_LINE_LOOP, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP, y GL_POLYGON.

glVertex

Denota los puntos donde se encontraran los vértices dentro de una primitiva, los parámetros que recibe son: (x, y, z, w)

glPushmatrix

Mete al stack una matriz

glPopmatrix

Saca del stack una matriz.

gltranslate

Produce una matriz de translación, los parámetros que recibe son (x, y, z)

glrotate

Multiplica por una matriz de rotación, los parámetros que recibe son (ángulo, x,y,z)

glscale

Produce un escalamiento no uniforme en los 3 ejes según los parámetros (x,y,z)

glclear()

regresa el area de un plano de bits de una ventana a valores plenamente preestablecidos por glClearColor, glClearIndex, glClearDepth, glClearStencil, y glClearAccum. Varios buffers pueden ser limpiados simultáneamente seleccionando más de un buffer usando glDrawBuffer.

glcrlear color

limpia valores buffers de color con los parámetros (rojo, azul, verde, alfa)

Concavidad de una función

Una función es cóncava si fijado un vector unitario en el semieje positivo OY, dicho vector está en el mismo semiplano (determinado por las rectas tangentes a la función) que la función. En caso contrario (distintos semiplanos) se dice convexa.

Bibliografía

Reporte/ Tarea Práctica 1 Computación Gráfica

Describa paso a paso de la manera más detallada posible la forma en que se crean un proyecto en visual studio 2005

¿Qué pasos hay que seguir para configurar un proyecto que pueda utilizar la librería GLUT?
1. Descargar de la pagina http://www.opengl.org/resources/libraries/glut/ el archivo glutdlls37beta.zip de la sección "Precompiled Win32 for Intel" y el "GLUT3.7 Source Code for Win32 ".

2. Descomprimirlos en una carpeta C:dev/ y acomodar los archivos lib en una carpeta lib, los dll en una carpeta dll y los .h a una carpeta GL dentro de include, todo esto dentro de la carpeta C:dev/

3. Modificar las variables de entorno agregando c:dev/dll; al final de la variable Path.

4. Abrir Microsoft Visual Studio 2005.

5. Crear un nuevo proyecto win32 escogiendo la opción “Console Application” y “Empty Proyect”

6. Indicar al proyecto donde se encuentra la ruta del directorio include y del directorio lib en las propiedades del proyecto.

¿Cuál es la diferencia entre crean un proyecto cpp win 32 application y un proyecto cpp win 32 project?

El proyecto de aplicación win 32 contiene instrucciones para el Shell, mientras que el Project no tiene Shell.

¿Cuál es la diferencia entre ejecutar la aplicación recién creada en modo de depuración y sin depurador?

En el modo de depuración podemos ver en cada paso la ejecución de la línea de comando viendo cómo cambian las variables en tiempo de ejecución.

¿Qué es una variable de entorno como se pueden crear y o modificar en Windows vista?

Una variable de entorno es un nombre asociado a una cadena de caracteres que por lo general indican una dirección. En “My PC” dar click derecho y luego en propiedades, avanzadas y editar las variables de entorno.

Aplicaciones de la Computacion Grafica

Este documento contiene información hacerca de las aplicaciones de la computacion grafica en la actualidad.
http://wyrven.iespana.es/CGA.doc

CRT, LSD, PLASMA

Entrada el 21 de Agosto del 2007
http://wyrven.iespana.es/pantallas.doc

Primera Entrada de mi Blog

^_^