PREVIO 7

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;
}

previo 6

1. Escribir el código que escripa en la pantalla de glut mi nombre y mi número de cuenta

#include "GL/glut.h"
#include "string.h"
char etiqueta[80];

void Escribe (char *cadena)
{
unsigned int Nletras;
for (Nletras=0; Nletras glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_10, cadena[Nletras]);
}
void texto(void)
{
char *nombre="Eduardo Ademir Hernández García";
char *númeroCuenta="301594679";
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode( GL_MODELVIEW_MATRIX );
glLoadIdentity();
glColor3f(1.0, 1.0, 1.0);
sprintf(etiqueta,"%s", nombre);
glRasterPos2f(95, 20);
texto(etiqueta);
sprintf(etiqueta,"%s", númeroCuenta);
glRasterPos2f(100, 35);
texto(etiqueta);
glFlush();
}
void reshape(int w, int h)
{
if (!h)
return;
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, w, 0, h);
glScalef(1, -1, 1);
glTranslatef(0, -h, 0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(300,320);
glutInitWindowPosition(0, 0);
glutCreateWindow("Cadenas Dibujadas");
glutDisplayFunc(texto);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

PRACTICA 4

Este es el código que dibuja a los 3 humanoides y al cubo con la esfera arriba y los brazos saliendo de ella.

#include
#include "cubo0.h"
#include "triangulo.h"

void mano (void)
{
glPushMatrix();
glScalef(1.2,1,1);
cubo();
glPopMatrix();
}

void brazo(void)
{
glPushMatrix();
glScalef(1,0.3,0.6);
cubo();
/*glPushMatrix();
glTranslatef(1.1,0,0);
mano();
glPopMatrix();*/
glPopMatrix();
}
void pierna(void)
{
glPushMatrix();
glScalef(0.5,3,1.1);
cubo();
glPopMatrix();
}

void brazoRobot(void)
{
//brazo
glPushMatrix();
glRotatef(30,0.0,0.0,1.0);
glTranslatef(0.0,1.5,0.0);
glPushMatrix();
glScalef(0.5,3.0,0.5);
cubo();
glPopMatrix();
//antebrazo

glTranslatef(0.0,1.5,0.0);
glRotatef(-30,0.0,0.0,1.0);
glTranslatef(0.0,1.0,0.0);
glPushMatrix();
glScalef(0.5,2.0,0.5);
cubo();
glPopMatrix();

//dedos
//dedo1
glPushMatrix();
glTranslatef(0.0,0.5,0.0);
glRotatef(10,0.0,0.0,1.0);
glTranslatef(-0.125,1.0,0.0);
glPushMatrix();
glScalef(0.25,1.0,0.5);
cubo();
glPopMatrix();
glPopMatrix();
//dedo2
glPushMatrix();
glTranslatef(0.0,0.5,0.0);
glRotatef(-10,0.0,0.0,1.0);
glTranslatef(0.125,1.0,0.0);
glPushMatrix();
glScalef(0.25,1.0,0.5);
cubo();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glFlush();
}

void monito (void)
{
glPushMatrix();
glTranslatef(0,1,0);
glScalef(1.2,1.5,1);
cubo(); //PECHO
glPushMatrix();
glTranslatef(0,0.75,0);
glScalef(0.75,0.6,0.8);
cubo(); //CABEZA
glPopMatrix();
glPushMatrix();
glTranslatef(1,0.15,0);
glRotatef(-20,0,0,1);
brazo(); //BRAZO DERECHO
glPopMatrix();
glPushMatrix();
glTranslatef(-1,0.15,0);
glRotatef(200,0,0,1);
brazo(); //BRAZO IZQUIERDO
glPopMatrix();
glPushMatrix();
glTranslatef(0,-0.75,0);
glScalef(0.8,0.5,0.8);
cubo(); //CINTURA
glPushMatrix();
glTranslatef(-0.35,-2,0);
pierna(); //PIERNA
glPushMatrix();
glTranslatef(-0.25,-1.75,0);
glScalef(1,0.5,1);
cubo();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glTranslatef(0.35,-2,0);
pierna();
glPushMatrix();
glTranslatef(0.25,-1.75,0);
glScalef(1,0.5,1);
cubo();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();

}

void escena (void)
{
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glClearDepth(1.0);
glClearColor(1.0,1.0,1.0,0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(50.0,1.0,1.0,100.0);

glMatrixMode(GL_MODELVIEW);

glPushMatrix();
glTranslatef(0,0,-7);
monito();
glPopMatrix();
glPushMatrix();
glTranslatef(7,-1.7,7);
glRotatef(-120,0,1,0);
glScalef(2,0.5,1);
monito();
glPopMatrix();
glPushMatrix();
glTranslatef(-7,1.7,7);
glRotatef(120,0,1,0);
glScalef(0.5,1.5,1);
monito();
glPopMatrix();
glPushMatrix();
glTranslatef(0,-3.3,0);
glScalef(3,3,3);
triangulo();
glPopMatrix();
glPushMatrix();
glTranslatef(0,0,0);
glScalef(1.5,5.5,1.5);
cubo();
glPushMatrix();
glTranslatef(0,1.3,0);
glColor3d(0.8,0.3,0.7);
glutWireSphere(0.8,30,30);
glPushMatrix();
glTranslatef(-0.8,0,0);
glScalef(1,0.1,1);
brazoRobot();
glPopMatrix();
glPushMatrix();
glTranslatef(0,0,0.8);
glRotatef(90,0,1,0);
glScalef(1,0.1,1);
brazoRobot();
glPopMatrix();
glPushMatrix();
glTranslatef(0,0,-0.8);
glRotatef(-90,0,1,0);
glScalef(1,0.1,1);
brazoRobot();
glPopMatrix();
glPushMatrix();
glTranslatef(0.8,0,0);
glRotatef(180,0,1,0);
glScalef(1,0.1,1);
brazoRobot();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glRotatef(45,1,1,1);
glFlush();
}

int main(int argc,char *argv)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA| GLUT_DEPTH );
glutInitWindowPosition(0,0);
glutInitWindowSize(600,600);
glutCreateWindow("Practica 4");
gluLookAt(0.0, 5.0, 25.0,0.0, 0.0, 0.0,0.0, 1.0, 0.0);
//Vista desde el punto 0,0,0. Con el 3er parámetro se acerca o se aleja la cámara
glutDisplayFunc(escena);
glutMainLoop();
return 0;
}


2. Para qué sirve tener una escena construida jerárquicamente?

Sirve para poder tener el control sobre el objeto o la escena que se crea, ya que de esta manera el movimiento o traslado de los objetos sucede de forma "natural", es decir, que por ejemplo si se desea mover algo que esta conectado o ligado a otra cosa, este objeto se mueva también. Esto lo vimos con el modelado del humanoide. Para que el humanoide pueda mover el pie por ejemplo es necesario mover la pierna o si se desea mover la cabeza se tenga que mover forzosamente la cabeza.

tarea 5

TAREA PROXIMAMENTE ..........

PREVIO 5

#include
#include
#include

void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}

void mouse(int button, int state, int x, int y)
{
if (state == GLUT_DOWN)
{
if ((glutGetWindow() == ventana1) && button == GLUT_LEFT_BUTTON)
{
xzoom = 255 - x;
yzoom = y - 255;
printf("%d, %d \n",x, y);
glutInitWindowSize (500, 500);
glutInitWindowPosition (700, 50);
ventana2 = glutCreateWindow ("Coordenadas especificas");
glutDisplayFunc(display_coordenadas);
glutReshapeFunc(reshape_coordenadas);
glutSetWindow(ventana2);
glutIdleFunc(NULL);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
}
else if ((glutGetWindow() == ventana2) && (button == GLUT_RIGHT_BUTTON)){
glutIdleFunc(NULL);
glutDestroyWindow(ventana2);
}
}
if (state == GLUT_UP)
{
if ((glutGetWindow() == ventana1) && button == GLUT_RIGHT_BUTTON)
{
printf("%d, %d \n",x, y);
glutInitWindowSize (800, 800);
glutInitWindowPosition (450, 0);
ventana3 = glutCreateWindow ("vENTANA3");
glutReshapeFunc(reshape_fractal);
glutSetWindow(ventana3);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
}
else if ((glutGetWindow() == ventana3) && (button == GLUT_RIGHT_BUTTON)){
glutIdleFunc(NULL);
glutDestroyWindow(ventana3);
//glutSetWindow(win1);
}
}
}

int main(int argc, char** argv)
{
//codigo para la primer ventana que despliega el fractal
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (700, 700);
glutInitWindowPosition (25, 50);
ventana1=glutCreateWindow ("Fractal Triangulo de Sierpenski Gasket");
glutSetWindow(ventana1);
init ();
glutDisplayFunc(mouse);
glutReshapeFunc(reshape_mouse);
glutIdleFunc(NULL);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMainLoop();
return 0;
}

TAREA 4: "PUERCO ARAÑA"

Este es el código para hacer el puerco araña

#include

GLUquadricObj * qobj;

void colaDePuerco (void)
{
glPushMatrix();
glTranslatef(0, 0,0); // cilindro al punto de origen (0,0,0)
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj,GLU_LINE);
gluCylinder(qobj, 0.8, 0.8, 1.5, 50,10);
glPopMatrix();
}

void cabezaDePuerco (void)
{
glPushMatrix();
glTranslatef(0,0,0);
glutWireSphere(3,10,10);
glPopMatrix();
}

void ojosDePuerco (void)
{
glPushMatrix();
glTranslatef(0, 0,0); // cilindro al punto de origen (0,0,0)
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj,GLU_LINE);
gluCylinder(qobj, 0.8, 0.8, 0.5, 100,5);
glPopMatrix();
}

void trompaDePuerco (void)
{
glPushMatrix();
glTranslatef(0, 0,0); // cilindro al punto de origen (0,0,0)
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj,GLU_LINE);
gluCylinder(qobj, 0.5, 0.5, 1, 8,6);
glPopMatrix();
}

void orejaDePuerco (void)
{
glPushMatrix();
glTranslatef(0,0,0);
glRotatef(-90,1,0,0);
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj,GLU_LINE);
gluCylinder(qobj, 1, 0, 1.3, 5,5);
glPopMatrix();
}

void patapuerco (void)
{
glPushMatrix();
glTranslatef(0, 0,0); // cylinder at (0,0,1)
glRotatef(90,1,0,0);
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj,GLU_LINE);
gluCylinder(qobj, 1, 1, 1.5, 10,8);
glPopMatrix();
}

void Puerco (void)
{
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glClearDepth(1.0);
glClearColor(1.0,1.0,1.0,0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(50.0,1.0,1.0,100.0);

glMatrixMode(GL_MODELVIEW);

//gluCylinder(qobj, baseRad, topRad, height, nSlices, nStacks); Dibuja el cilindro
/*glPushMatrix();
glTranslated(0, 0,0); // cylinder at (0,0,1)
glRotatef(90,1,0,0);
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj,GLU_LINE);
glColor3d(0.1,0.3,0.7);
gluCylinder(qobj, 0.3, 1.3, 5.4, 10,8);
glPopMatrix();*/

glPushMatrix();
glColor3d(0.1,0.3,0.7);
glTranslatef(0,0,0);
glRotatef(90,0,1,0);
glutWireSphere(4,8,8);

glPushMatrix();
glTranslatef(-2.5,-2,2);
patapuerco();
glPopMatrix();

glPushMatrix();
glTranslatef(-2.5,-2,-2);
patapuerco();
glPopMatrix();

glPushMatrix();
glTranslatef(2.5,-2,2);
patapuerco();
glPopMatrix();

glPushMatrix();
glTranslatef(2.5,-2,-2);
patapuerco();
glPopMatrix();

glPushMatrix();
glTranslatef(0,1,4);
cabezaDePuerco();

glPushMatrix();
glTranslatef(-1.4,2,0.5);
orejaDePuerco();
glPopMatrix();

glPushMatrix();
glTranslatef(1.4,2,0.5);
orejaDePuerco();
glPopMatrix();

glPushMatrix();
glTranslatef(0,0,2.8);
trompaDePuerco();
glPopMatrix();

glPushMatrix();
glTranslatef(1.2,1.2,1.9);
ojosDePuerco();
glPopMatrix();

glPushMatrix();
glTranslatef(-1.2,1.2,1.9);
ojosDePuerco();
glPopMatrix();
glPopMatrix();

glPushMatrix();
glTranslatef(0,0,-5.5);
colaDePuerco();
glPopMatrix();

glPopMatrix();

glRotatef(45,1,1,1);
glFlush();
}

int main(int argc,char *argv)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA| GLUT_DEPTH );
glutInitWindowPosition(0,0);
glutInitWindowSize(600,600);
glutCreateWindow("Puerco Araña");
gluLookAt(0.0, 5.0, 20.0,0.0, 0.0, 0.0,0.0, 1.0, 0.0);
//Vista desde el punto 0,0,0. Con el 3er parámetro se acerca o se aleja la cámara
glutDisplayFunc(Puerco);
glutMainLoop();
return 0;
}