Previo 6

¿Cómo se dibuja texto con GLUT? ¿Cambia el dibujo de texto con freeGLUT y OpenGLUT? ¿Porque?

El manejo de fuentes de texto es una de las partes débiles de OpenGL. Su implementación es complicada ya que la biblioteca GL sólo proporciona funciones muy primitivas para trazado de bitmaps que obligan a disponer de una librería propia de bitmaps para los caracteres. GLUT va un poco más allá y dispone de unas pocas funciones que permiten renderizar texto en pantalla.
GLUT resuelve un poco el dilema de usar texto en OpenGL. Proporciona glutBitmapCharacter, que traza un único carácter en la posiciçón especificada por glRasterPos. He añadido unas pocas funciones, drawString(), y drawStringBig() que hacen la vida un poco mejor al trazar cadenas de caracteres.

¿Cómo funcionan y cúales son los parámetros de los comandos ?

glutBitmapCharacter(*font vacío, carácter interno); Traza un único caracter en la posición especificada. Los parámetros son la fuente a usar, y el caracter que va a escribir.

glutStrokeCharacter(*font vacío, carácter interno); Rinde un carácter del movimiento que usa OpenG. Tiene los mismos parámetros que el anterior caso.

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

void escribe(char * s)
{
int i;
for(i=0;
glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18,s[i]);
}

void disp(void){
glClear(GL_COLOR_BUFFER_BIT);glFlush();
}
int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA GLUT_SINGLE);
glutInitWindowSize(500,500);
glutInitWindowPosition(100,100);
glutCreateWindow("TEXTO");
glClearColor(0.0,0.0,0.0,0.0);
glutDisplayFunc(disp);
glutMainLoop();
}

Reporte práctica 5

¿Qué es diseño orientado a eventos?

Es un diseño que se basa en la ocurrencia de eventos, es decir, esperar que el usuario realice una acción en la ventana (un click, oprimir una tecla, o el simple movimiento del raton), para que el programa interactue como respuesta a ese evento realizando una acción.



¿Qué utilidad tiene el manejo de eventos en el desarrollo de aplicaciones gráficas?



Los lenguajes visuales orientada al evento y con manejo de componentes dan al usuario que no cuenta con mucha experiencia en desarrollo, la posibilidad de construir sus propias aplicaciones utilizando interfaces gráficas sobre la base de ocurrencia de eventos.Para soportar este tipo de desarrollo interactuan dos tipos de herramientas, una que permite realizar diseños gráficos y , un lenguaje de alto nivel que permite codificar los eventos. Con dichas herramientas es posible desarrollar cualquier tipo de aplicaciones basadas en el entorno.



Escriba un programa en el cual se tomen las coordenadas y se dibuje un punto,
- Cada 2 puntos acumulados dibuje una línea

#include
#include
#include
using namespace std;
int point1[]={10,10};
int point2[]={50,50};
int click=0;

void onMouse(int button, int state, int x, int y)
{
if ( (button == GLUT_LEFT_BUTTON) && (state == GLUT_DOWN) ) {
click++;
if (click==1){
point1[0]=x;
point1[1]=y;
}
if (click==2){
point2[0]=x;
point2[1]=y;
glutPostRedisplay();
}
if (click==3){
point1[0]=x;
point1[1]=y;
click=1; }

if ( (button == GLUT_RIGHT_BUTTON) && (state == GLUT_DOWN) ) {
glClear(GL_COLOR_BUFFER_BIT);
}

}
}

void disp(void){
glutMouseFunc(onMouse);
glClear(GL_COLOR_BUFFER_BIT); // se limpia pantalla
glColor3f(110.0/255.0,191.0/255.0,116.0/255.0);
glBegin(GL_LINES); //para crear líneas
//dibujo de linea entre puntos
glVertex2f(-1.0+((float)point1[0]/250.0),1.0-((float)point1[1]/250.0));
glVertex2f(-1.0+((float)point2[0]/250.0),1.0-((float)point2[1]/250.0));
glEnd();
glFlush();
}

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

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA GLUT_SINGLE);
glutInitWindowSize(500,500);

glutInitWindowPosition(100,100);

glutCreateWindow("LINEAS");

glClearColor(0.0,0.0,0.0,0.0);
glutDisplayFunc(disp);

glutMainLoop();
}

- Cada tres puntos acumulados dibuje un triangulo

#include
#include
#include
using namespace std;
int point1[]={10,10};
int point2[]={50,50};
int point3[]={10,50}
int click=0;

void onMouse(int button, int state, int x, int y)
{
if ( (button == GLUT_LEFT_BUTTON) && (state == GLUT_DOWN) ) {
click++;
if (click==1){
point1[0]=x;
point1[1]=y;
}
if (click==2){
point2[0]=x;
point2[1]=y;
glutPostRedisplay();
}
if(click==3){
point3[0]=x;
point3[1]=1;
glutPostRedisplay();
}

if (click==4){
point1[0]=x;
point1[1]=y;
click=1;
}
if ( (button == GLUT_RIGHT_BUTTON) && (state == GLUT_DOWN) ) {
glClear(GL_COLOR_BUFFER_BIT);
}
}
}

void disp(void){
glutMouseFunc(onMouse);
glClear(GL_COLOR_BUFFER_BIT); // se limpia pantalla
glColor3f(110.0/255.0,191.0/255.0,116.0/255.0);
glBegin(GL_LINES); //para crear líneas
//dibujo de linea entre puntos
glVertex2f(-1.0+((float)point1[0]/250.0),1.0-((float)point1[1]/250.0));
glVertex2f(-1.0+((float)point2[0]/250.0),1.0-((float)point2[1]/250.0));
glvertex2f(-1.0+((float)point3[0]/250.0),1.0-((float)point3[1]/250.0));
glEnd();
glFlush();
}

int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA GLUT_SINGLE);
glutInitWindowSize(500,500);

glutInitWindowPosition(100,100);

glutCreateWindow("LINEAS");

glClearColor(0.0,0.0,0.0,0.0);
glutDisplayFunc(disp);

glutMainLoop();
}

Previo 5.

Escriba una aplicación que usando la libreria GLUT detecte que se ha realizadoun click con el botón derecho del mouse sobre la ventana principal e imprima la coordenadas del mouse en la sálida estándar. Cuando se haga click en el botón izquierdo, cierre la aplicación. Nota: Usar glutMouseFunc().

void Mouse(int button, int state, int x, int y) {
if ( (button == GLUT_RIGHT_BUTTON && state == GLUT_DOWN) ) {
printf("Botón derecho\n");
printf("X=%f\n", (GLfloat)GLsizei x);
printf("Y=%f\n", (GLfloat)GLsizei y);
cout << "\nPOSICION X:" <<>
cout << "\nPOSICION Y:" << y;
}

if ( (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) )
{
exit(0);
}

}

void disp(void){
glClear(GL_COLOR_BUFFER_BIT);
glutMouseFunc(Mouse);
glFlush();
}

int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA GLUT_SINGLE);
glutInitWindowSize(500,500);
glutInitWindowPosition(100,100);
glutCreateWindow("RATON");
glClearColor(0.0,0.0,0.0,0.0);
glutDisplayFunc(disp);
glutMainLoop();
}

¿Qué comandos para manejo de eventos nos proporciona GLUT?
Un evento es algo que el usuario puede hacer, dentro de una ventana.
Las funciones más comunes que GLUT llama automáticamente al detectar un evento son:

glutMouseFunc(función de control de eventos con el ratón);

glutMotionFunc(función de control de eventos de movimiento del ratón);

glutReshapeFunc(función de control del cambio de tamaño de la ventana de visualización);

glutKeyboardFunc(función de control de eventos con el teclado);

glutDisplayFunc(función de control del render);

glutIdleFunc(función que se activa cuando no se hace nada);

Previo 5.

Previo

Reporte Práctica 4.

1. Describa la ventajas y desventaja de construir de manera jerárquica escenas


Dentro de las ventahas esta de que los efectos sobre objetos relacionados se propaguen automáticamente a través de ciertos grupos. Esté método (jerárquico) es muy útil cuando se asocia a transformaciones geométricas ya que sería demasiado complicado rotar, trasladar y escalar una y otra vez algunos objetos que están relacionados, en vez de esto es más fácil encontrar la relación que existe entre dichos objetos y solo tener que hacer pocas transformaciones para lograr los resultados deseados.

2. Escriba un programa que construya de manera jerárquica una escena en la que haya 3 humanoides.

void init(void){

glClearColor (0.0, 0.0, 0.0, 0.0);

glShadeModel (GL_FLAT);

}

void cubohum(void){

glBegin(GL_LINE_LOOP);

glVertex3f(0.5,0.5,0.5);

glVertex3f(-0.5,0.5,0.5);

glVertex3f(-0.5,-0.5,0.5);

glVertex3f(0.5,-0.5,0.5);

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3f(-0.5,0.5,-0.5);

glVertex3f( 0.5,0.5,-0.5);

glVertex3f(0.5,-0.5,-0.5);

glVertex3f(-0.5,-0.5,-0.5);

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3f(-0.5,0.5,0.5);

glVertex3f(-0.5,0.5,-0.5);

glVertex3f(-0.5,-0.5,-0.5);

glVertex3f(-0.5,-0.5,0.5);

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3f(0.5,0.5,0.5);

glVertex3f(0.5,-0.5,0.5);

glVertex3f( 0.5,-0.5,-0.5);

glVertex3f(0.5,0.5,-0.5);

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3f(-0.5,0.5,-0.5);

glVertex3f(-0.5,0.5,0.5);

glVertex3f(0.5,0.5,0.5);

glVertex3f( 0.5,0.5,-0.5);

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3f(0.5,-0.5,-0.5);

glVertex3f(-0.5,-0.5,-0.5);

glVertex3f(-0.5,-0.5,0.5);

glVertex3f(0.5,-0.5,0.5);

glEnd();

}

void torso (int posx,int posy,int posz){

glTranslatef(0.0,1.5,0.0);

glScalef (0.5, 0.5, 0.5);

glRotatef(posx,1.0,0.0,0.0);

glRotatef(posy,0.0,1.0,0.0);

glRotatef(posz,0.0,0.0,1.0);

glTranslatef(0.0,0.0,0.0);

glPushMatrix();

glScalef (2.0, 3.0, 1.0);

cubohum();

glPopMatrix();

}

void rostro (int cuey){

glPushMatrix();

glRotatef(cuey,0.0,1.0,0.0);

glTranslatef(0.0,2.0,0.0);

cubohum();

glPopMatrix();

}

void brazoder (int hombrodx,int hombrody,int hombrodz,int cododz){

glPushMatrix();

glTranslatef(1.0,1.0,0.0);

glRotatef(hombrodx,1.0,0.0,0.0);

glRotatef(hombrody,0.0,1.0,0.0);

glRotatef(hombrodz,0.0,0.0,1.0);

glTranslatef(1.0,0.25,0.0);

glPushMatrix();

glScalef(2.0,0.5,1.0);

cubohum();

glPopMatrix();

glTranslatef(1.0,0.0,0.0);

glRotatef(cododz,0.0,0.0,1.0);

glTranslatef(1.0,0.0,0.0);

glPushMatrix();

glScalef(2.0,1.0,1.0);

cubohum();

glPopMatrix();

glTranslatef(1.25,0.0,0.0);

glPushMatrix();

glScalef(0.5,0.5,1.0);

cubohum();

glPopMatrix();

glPopMatrix();

}

void brazoizq (int hombroix,int hombroiy,int hombroiz,int codoiz){

glPushMatrix();

glTranslatef(-1.0,1.0,0.0);

glRotatef(hombroix,1.0,0.0,0.0);

glRotatef(hombroiy,0.0,1.0,0.0);

glRotatef(hombroiz,0.0,0.0,1.0);

glTranslatef(-1.0,0.25,0.0);

glPushMatrix();

glScalef(2.0,0.5,1.0);

cubohum();

glPopMatrix();

glTranslatef(-1.0,0.0,0.0);

glRotatef(codoiz,0.0,0.0,1.0);

glTranslatef(-1.0,0.0,0.0);

glPushMatrix();

glScalef(2.0,1.0,1.0);

cubohum();

glPopMatrix();

glTranslatef(-1.25,0.0,0.0);

glPushMatrix();

glScalef(0.5,0.5,1.0);

cubohum();

glPopMatrix();

glPopMatrix();

}

void piernader(int muslodx,int muslody,int muslodz,int rodilladx,int piedy){

glPushMatrix();

glTranslatef(0.665,-1.5,0.0);

glRotatef(muslodx,1.0,0.0,0.0);

glRotatef(muslody,0.0,1.0,0.0);

glRotatef(muslodz,0.0,0.0,1.0);

glTranslatef(0.0,-1.2,0.0);

glPushMatrix();

glScalef(0.68,2.4,1.0);

cubohum();

glPopMatrix();

glTranslatef(0.0,-1.2,0.0);

glRotatef(rodilladx,1.0,0.0,0.0);

glTranslatef(0.0,-1.2,0.0);

glPushMatrix();

glScalef(1.0,2.4,1.0);

cubohum();

glPopMatrix();

glTranslatef(0.0,0.-1.25,0.0);

glRotatef(piedy,0.0,1.0,0.0);

glTranslatef(0.25,-0.35,0.0);

glPushMatrix();

glScalef(1.5,0.75,1.0);

cubohum();

glPopMatrix();

glPopMatrix();

}

void piernaizq(int musloix,int musloiy,int musloiz,int rodillaix,int pieiy){

glPushMatrix();

glTranslatef(-0.665,-1.5,0.0);

glRotatef(musloix,1.0,0.0,0.0);

glRotatef(musloiy,0.0,1.0,0.0);

glRotatef(musloiz,0.0,0.0,1.0);

glTranslatef(0.0,-1.2,0.0);

glPushMatrix();

glScalef(0.68,2.4,1.0);

cubohum();

glPopMatrix();

glTranslatef(0.0,-1.2,0.0);

glRotatef(rodillaix,1.0,0.0,0.0);

glTranslatef(0.0,-1.2,0.0);

glPushMatrix();

glScalef(1.0,2.4,1.0);

cubohum();

glPopMatrix();

glTranslatef(0.0,0.-1.25,0.0);

glRotatef(pieiy,0.0,1.0,0.0);

glTranslatef(-0.25,-0.35,0.0);

glPushMatrix();

glScalef(1.5,0.75,1.0);

cubohum();

glPopMatrix();

glPopMatrix();

}

void humanoides (int px,int py,int pz,int cy,int hdx,int hdy,int hdz,int cdz,int hix,

int hiy,int hiz,int ciz,int mdx,int mdy,int mdz,int rdx,

int pdy,int mix,int miy,int miz,int rix,int piy)

{

torso(px,py,pz);

rostro(cy);

brazoder(hdx,hdy,hdz,cdz);

brazoizq(hix,hiy,hiz,ciz);

piernader(mdx,mdy,mdz,rdx,pdy);

piernaizq(mix,miy,miz,rix,piy);

}

/*Aqui se colocan los tres humanoides*/

void display(void){

glClear (GL_COLOR_BUFFER_BIT);

glColor3f (1.0, 1.0, 1.0);

glLoadIdentity ();

gluLookAt (0.0,0.0,10.0,0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

glPushMatrix();

glScalef(0.5,0.5,0.5);

glRotatef(-45,0.0,1.0,0.0);

glTranslatef(5.0,0.0,2.0);

humanoides(posicionx,posiciony,posicionz,cuelloy,hombroderx,hombrodery,hombroderz,cododerz,

hombroizqx,hombroizqy,hombroizqz,codoizqz,musloderx,muslodery,musloderz,rodilladerx,

piedery,musloizqx,musloizqy,musloizqz,rodillaizqx,pieizqy);

glPopMatrix();

glPushMatrix();

glTranslatef(1.0,1.0,1.0);

glRotatef(15,1.0,0.0,0.0);

glScalef(0.5,-1.5,0.8);

humanoides(posicionx,posiciony,posicionz,cuelloy,hombroderx,hombrodery,hombroderz,cododerz,

hombroizqx,hombroizqy,hombroizqz,codoizqz,musloderx,muslodery,musloderz,rodilladerx,

piedery,musloizqx,musloizqy,musloizqz,rodillaizqx,pieizqy);

glPopMatrix();

glPushMatrix();

glRotatef(20,0.0,1.0,0.0);

glTranslatef(-2.0,-1.0,-3.0);

humanoides(posicionx,posiciony,posicionz,cuelloy,hombroderx,hombrodery,hombroderz,cododerz,

hombroizqx,hombroizqy,hombroizqz,codoizqz,musloderx,muslodery,musloderz,rodilladerx,

piedery,musloizqx,musloizqy,musloizqz,rodillaizqx,pieizqy);

glPopMatrix();

glFlush ();

}

void reshape (int w, int h){

glViewport (0, 0, (GLsizei) w, (GLsizei) h);

glMatrixMode (GL_PROJECTION);

glLoadIdentity ();

glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);

glMatrixMode (GL_MODELVIEW);

}

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

glutInit(&argc, argv);

glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);

glutInitWindowSize (800, 800);

glutInitWindowPosition (90, 90);

glutCreateWindow (argv[0]);

init ();

glutDisplayFunc(display);

glutReshapeFunc(reshape);

glutKeyboardFunc(keyboard);

glutMainLoop();

return 0;

Reporte Práctica2.

1. Escriba u programa en el cual:
- Se dibuja un cuadrado.

void cuad() {
glBegin(GL_POLYGON);
glVertex3f(0.6,0.6,0.6);
glVertex3f(-0.6,0.,0.6);
glVertex3f(-0.6,-0.6,0.6);
glVertex3f(0.6,-0.6,0.6);

- Utilizando las llamadas al cuadrado y aplicando rotaciones y transformaciones, dibuje un cubo.

cuad();
glRotatef(30.0,1.0,0.0,0.0);
glTranslatef(0.5,0.5,-0.5);
glScalef(2.0,0.5,1.0);

Se aplican más transformaciones para obtener el cubo.

Previo 3.

1. ¿Qué es una composición de transformaciones?

Una matriz de transformación describe todas las transformaciones (traslación, escalado, rotación, deformación) que modifican la matriz de un determinado objeto. Para poder animar o mover un objeto dentro del ambiente en que esta descrito es necesario realizar transformaciones succesivas que modifiquen la matriz que describe dicho objeto, a esto se le conoce como composicion de transformaciones.

• La composición de transformaciones se realiza mediante el producto de matrices

• Se pueden obtener los valores de la transformación a partir de la matriz: desplazamiento, escala y giro.

2. ¿Afecta el orden en el cual se aplican las transformaciones sobre un vector o conjunto de vectores?, ¿por qué?

El orden de las transformaciones es importante. En general, un orden de rotación, ajuste de escala y traslación no es lo mismo que un orden de ajuste de escala, rotación y traslación. Análogamente, el orden de multiplicación de matrices es importante. En general, ABC no es lo mismo que BAC.

3. Es lo mismo:

glRotatef(30.0,1.0,0.0,0.0);

gltranslate(1,1,1);

glScalef(2.0,2.0,2.0);

cubo();

qué:

cubo();

glRotatef(30.0,1.0,0.0,0.0);
gltranslate(1,1,1);
glScalef(2.0,2.0,2.0);

o qué:

glScalef(2.0,2.0,2.0);

glRotatef(30.0,1.0,0.0,0.0);
gltranslate(1,1,1);
glScalef(2.0,2.0,2.0);

cubo();

No es el mismo resultado, ya que en algunos se llama primero a la figura y después se transforma, y en otra sección se aplican transformaciones y luego se llama a la figura, además como se mencionó antes, si importa el orden de las transformaciones.

4. ¿Qué es un modelado jerárquico?

Es la aplicación de límites de conectividad (o colocación relativa) entre objetos organizados en una estructura de árbol.

Un tipo de modelo jerárquico común usado en gráficas tiene objetos que estan conectados en sus extremos por cadenas de extremidades.

5. ¿Cómo se modela jerarquicamente el humanoide?

Primero se modela el cuadro central, es decir el cuerpo, de ahi se van modelando los brazos, las manos. También de ahi se modelan las extremidades inferiores, y la cabeza.