domingo, 27 de noviembre de 2016
Ejercicio 6
ENUNCIADO
Modificar el codigo fuente del ejercicio 5 para que se pueda elegir la forma del objeto dentro del menu. Se debe elegir entre tres formas distintas por ejemplo una tetera una esfera y un cubo.
FIGURA
CODIGO FUENTE
//modificar para que cambie la figura geometrica desde menu.
#include <stdio.h>
#include <stdlib.h>
#include <GL/glx.h> /* this includes the necessary X headers */
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <X11/X.h> /* X11 constant (e.g. TrueColor) */
#include <X11/keysym.h>
int iFondo=0;
int iDibujo=3;
GLfloat iTamano=0.5;
GLfloat xpos=0.0,ypos=0.0;
int iFigura=9;
typedef enum {FONDO1,FONDO2,FONDO3,DIBUJO1,DIBUJO2,DIBUJO3,TAMANO1,TAMANO2,TAMANO3,
FIGURA1,FIGURA2,FIGURA3}
opcionesMenu;
void onMenu (int opcion) {
switch (opcion) {
case FONDO1:
iFondo=0;
break;
case FONDO2:
iFondo=1;
break;
case FONDO3:
iFondo=2;
break;
case DIBUJO1:
iDibujo=3;
break;
case DIBUJO2:
iDibujo=4;
break;
case DIBUJO3:
iDibujo=5;
break;
case TAMANO1:
iTamano++;
break;
break;
case TAMANO2:
iTamano=0.5;
break;
break;
case TAMANO3:
iTamano=iTamano-0.1;
break;
case FIGURA1:
iFigura=9;
break;
case FIGURA2:
iFigura=10;
break;
case FIGURA3:
iFigura=11;
break;
}
glutPostRedisplay();
}
void creacionMenu () {
int menuFondo,menuDibujo,menuPrincipal,menuTamano,menuFigura;
menuFondo= glutCreateMenu(onMenu);
glutAddMenuEntry("Negro",FONDO1);
glutAddMenuEntry("Verde oscuro",FONDO2);
glutAddMenuEntry("Azul oscuro",FONDO3);
menuDibujo=glutCreateMenu(onMenu);
glutAddMenuEntry("Blanco",DIBUJO1);
glutAddMenuEntry("Verde claro",DIBUJO2);
glutAddMenuEntry("Azul claro",DIBUJO3);
menuTamano=glutCreateMenu(onMenu);
glutAddMenuEntry("GRANDE",TAMANO1);
glutAddMenuEntry("NORMAL",TAMANO2);
glutAddMenuEntry("REDUCIDO",TAMANO3);
menuFigura=glutCreateMenu(onMenu);
glutAddMenuEntry("Tetera",FIGURA1);
glutAddMenuEntry("Esfera",FIGURA2);
glutAddMenuEntry("Cubo",FIGURA3);
menuPrincipal = glutCreateMenu(onMenu);
glutAddSubMenu("Cambiar tamano",menuTamano);
glutAddSubMenu("Color de fondo",menuFondo);
glutAddSubMenu("Color de dibujo",menuDibujo);
glutAddSubMenu("Cambiar figura",menuFigura);
glutAttachMenu(GLUT_RIGHT_BUTTON);
}
void ControlTeclado (unsigned char key) {
switch (key) {
case 'o':
xpos=xpos-0.1;
break;
case 'p':
xpos=xpos+0.1;
break;
case 'q':
ypos=ypos+0.1;
break;
case 'a':
ypos=ypos-0.1;
break;
}
glutPostRedisplay();
}
void display() {
float colores [6] [3] = {
{0.00f,0.00f,0.00f}, // 0-negro
{0.06f,0.25f,0.13f}, // 1-verde oscuro
{0.10f,0.07f,0.33f}, // 2-azul oscuro
{1.00f,1.00f,1.00f}, // 3-blanco
{0.12f,0.50f,0.26f}, // 4-verde claro
{0.20f,0.14f,0.66f}, // 5-azul claro
};
glTranslatef(xpos,ypos,0.0f);
glClearColor(colores[iFondo][0],colores[iFondo][1],colores[iFondo][2],1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(colores[iDibujo][0],colores[iDibujo][1],colores[iDibujo][2]);
switch (iFigura) {
case 9:
glutWireTeapot(iTamano);
break;
case 10:
glutWireSphere(iTamano,16,16);
break;
case 11:
glutWireCube(iTamano);
break;
}
xpos=0.0;
ypos=0.0;
glFlush();
glutSwapBuffers();
}
int main (int argc,char** argv) {
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(700,700);
glutInitWindowPosition(200,200);
glutCreateWindow("Ejercicio 3 ejemplo menus");
glutDisplayFunc(display);
creacionMenu();
glutKeyboardFunc(ControlTeclado);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
Modificar el codigo fuente del ejercicio 5 para que se pueda elegir la forma del objeto dentro del menu. Se debe elegir entre tres formas distintas por ejemplo una tetera una esfera y un cubo.
FIGURA
CODIGO FUENTE
//modificar para que cambie la figura geometrica desde menu.
#include <stdio.h>
#include <stdlib.h>
#include <GL/glx.h> /* this includes the necessary X headers */
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <X11/X.h> /* X11 constant (e.g. TrueColor) */
#include <X11/keysym.h>
int iFondo=0;
int iDibujo=3;
GLfloat iTamano=0.5;
GLfloat xpos=0.0,ypos=0.0;
int iFigura=9;
typedef enum {FONDO1,FONDO2,FONDO3,DIBUJO1,DIBUJO2,DIBUJO3,TAMANO1,TAMANO2,TAMANO3,
FIGURA1,FIGURA2,FIGURA3}
opcionesMenu;
void onMenu (int opcion) {
switch (opcion) {
case FONDO1:
iFondo=0;
break;
case FONDO2:
iFondo=1;
break;
case FONDO3:
iFondo=2;
break;
case DIBUJO1:
iDibujo=3;
break;
case DIBUJO2:
iDibujo=4;
break;
case DIBUJO3:
iDibujo=5;
break;
case TAMANO1:
iTamano++;
break;
break;
case TAMANO2:
iTamano=0.5;
break;
break;
case TAMANO3:
iTamano=iTamano-0.1;
break;
case FIGURA1:
iFigura=9;
break;
case FIGURA2:
iFigura=10;
break;
case FIGURA3:
iFigura=11;
break;
}
glutPostRedisplay();
}
void creacionMenu () {
int menuFondo,menuDibujo,menuPrincipal,menuTamano,menuFigura;
menuFondo= glutCreateMenu(onMenu);
glutAddMenuEntry("Negro",FONDO1);
glutAddMenuEntry("Verde oscuro",FONDO2);
glutAddMenuEntry("Azul oscuro",FONDO3);
menuDibujo=glutCreateMenu(onMenu);
glutAddMenuEntry("Blanco",DIBUJO1);
glutAddMenuEntry("Verde claro",DIBUJO2);
glutAddMenuEntry("Azul claro",DIBUJO3);
menuTamano=glutCreateMenu(onMenu);
glutAddMenuEntry("GRANDE",TAMANO1);
glutAddMenuEntry("NORMAL",TAMANO2);
glutAddMenuEntry("REDUCIDO",TAMANO3);
menuFigura=glutCreateMenu(onMenu);
glutAddMenuEntry("Tetera",FIGURA1);
glutAddMenuEntry("Esfera",FIGURA2);
glutAddMenuEntry("Cubo",FIGURA3);
menuPrincipal = glutCreateMenu(onMenu);
glutAddSubMenu("Cambiar tamano",menuTamano);
glutAddSubMenu("Color de fondo",menuFondo);
glutAddSubMenu("Color de dibujo",menuDibujo);
glutAddSubMenu("Cambiar figura",menuFigura);
glutAttachMenu(GLUT_RIGHT_BUTTON);
}
void ControlTeclado (unsigned char key) {
switch (key) {
case 'o':
xpos=xpos-0.1;
break;
case 'p':
xpos=xpos+0.1;
break;
case 'q':
ypos=ypos+0.1;
break;
case 'a':
ypos=ypos-0.1;
break;
}
glutPostRedisplay();
}
void display() {
float colores [6] [3] = {
{0.00f,0.00f,0.00f}, // 0-negro
{0.06f,0.25f,0.13f}, // 1-verde oscuro
{0.10f,0.07f,0.33f}, // 2-azul oscuro
{1.00f,1.00f,1.00f}, // 3-blanco
{0.12f,0.50f,0.26f}, // 4-verde claro
{0.20f,0.14f,0.66f}, // 5-azul claro
};
glTranslatef(xpos,ypos,0.0f);
glClearColor(colores[iFondo][0],colores[iFondo][1],colores[iFondo][2],1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(colores[iDibujo][0],colores[iDibujo][1],colores[iDibujo][2]);
switch (iFigura) {
case 9:
glutWireTeapot(iTamano);
break;
case 10:
glutWireSphere(iTamano,16,16);
break;
case 11:
glutWireCube(iTamano);
break;
}
xpos=0.0;
ypos=0.0;
glFlush();
glutSwapBuffers();
}
int main (int argc,char** argv) {
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(700,700);
glutInitWindowPosition(200,200);
glutCreateWindow("Ejercicio 3 ejemplo menus");
glutDisplayFunc(display);
creacionMenu();
glutKeyboardFunc(ControlTeclado);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
EJERCICIO 5
ENUNCIADO
Modificar el codigo del ejercicio 4 para que la tetera se pueda mover arriba abajo izquierda y derecha con el teclado.
CODIGO FUENTE
//modificar para que se mueva en el plano
#include <stdio.h>
#include <stdlib.h>
#include <GL/glx.h> /* this includes the necessary X headers */
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <X11/X.h> /* X11 constant (e.g. TrueColor) */
#include <X11/keysym.h>
int iFondo=0;
int iDibujo=3;
GLfloat iTamano=0.5;
GLfloat xpos=0.0,ypos=0.0;
typedef enum {FONDO1,FONDO2,FONDO3,DIBUJO1,DIBUJO2,DIBUJO3,TAMANO1,TAMANO2,TAMANO3}
opcionesMenu;
void onMenu (int opcion) {
switch (opcion) {
case FONDO1:
iFondo=0;
break;
case FONDO2:
iFondo=1;
break;
case FONDO3:
iFondo=2;
break;
case DIBUJO1:
iDibujo=3;
break;
case DIBUJO2:
iDibujo=4;
break;
case DIBUJO3:
iDibujo=5;
break;
case TAMANO1:
iTamano++;
break;
break;
case TAMANO2:
iTamano=0.5;
break;
break;
case TAMANO3:
iTamano=iTamano-0.1;
break;
}
glutPostRedisplay();
}
void creacionMenu () {
int menuFondo,menuDibujo,menuPrincipal,menuTamano;
menuFondo= glutCreateMenu(onMenu);
glutAddMenuEntry("Negro",FONDO1);
glutAddMenuEntry("Verde oscuro",FONDO2);
glutAddMenuEntry("Azul oscuro",FONDO3);
menuDibujo=glutCreateMenu(onMenu);
glutAddMenuEntry("Blanco",DIBUJO1);
glutAddMenuEntry("Verde claro",DIBUJO2);
glutAddMenuEntry("Azul claro",DIBUJO3);
menuTamano=glutCreateMenu(onMenu);
glutAddMenuEntry("GRANDE",TAMANO1);
glutAddMenuEntry("NORMAL",TAMANO2);
glutAddMenuEntry("REDUCIDO",TAMANO3);
menuPrincipal = glutCreateMenu(onMenu);
glutAddSubMenu("Cambiar tamano",menuTamano);
glutAddSubMenu("Color de fondo",menuFondo);
glutAddSubMenu("Color de dibujo",menuDibujo);
glutAttachMenu(GLUT_RIGHT_BUTTON);
}
void ControlTeclado (unsigned char key) {
switch (key) {
case 'o':
xpos=xpos-0.1;
break;
case 'p':
xpos=xpos+0.1;
break;
case 'q':
ypos=ypos+0.1;
break;
case 'a':
ypos=ypos-0.1;
break;
}
glutPostRedisplay();
}
void display() {
float colores [6] [3] = {
{0.00f,0.00f,0.00f}, // 0-negro
{0.06f,0.25f,0.13f}, // 1-verde oscuro
{0.10f,0.07f,0.33f}, // 2-azul oscuro
{1.00f,1.00f,1.00f}, // 3-blanco
{0.12f,0.50f,0.26f}, // 4-verde claro
{0.20f,0.14f,0.66f}, // 5-azul claro
};
glTranslatef(xpos,ypos,0.0f);
glClearColor(colores[iFondo][0],colores[iFondo][1],colores[iFondo][2],1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(colores[iDibujo][0],colores[iDibujo][1],colores[iDibujo][2]);
glutWireTeapot(iTamano);
xpos=0.0;
ypos=0.0;
glFlush();
glutSwapBuffers();
}
int main (int argc,char** argv) {
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(700,700);
glutInitWindowPosition(200,200);
glutCreateWindow("Ejercicio 3 ejemplo menus");
glutDisplayFunc(display);
creacionMenu();
glutKeyboardFunc(ControlTeclado);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
Modificar el codigo del ejercicio 4 para que la tetera se pueda mover arriba abajo izquierda y derecha con el teclado.
CODIGO FUENTE
//modificar para que se mueva en el plano
#include <stdio.h>
#include <stdlib.h>
#include <GL/glx.h> /* this includes the necessary X headers */
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <X11/X.h> /* X11 constant (e.g. TrueColor) */
#include <X11/keysym.h>
int iFondo=0;
int iDibujo=3;
GLfloat iTamano=0.5;
GLfloat xpos=0.0,ypos=0.0;
typedef enum {FONDO1,FONDO2,FONDO3,DIBUJO1,DIBUJO2,DIBUJO3,TAMANO1,TAMANO2,TAMANO3}
opcionesMenu;
void onMenu (int opcion) {
switch (opcion) {
case FONDO1:
iFondo=0;
break;
case FONDO2:
iFondo=1;
break;
case FONDO3:
iFondo=2;
break;
case DIBUJO1:
iDibujo=3;
break;
case DIBUJO2:
iDibujo=4;
break;
case DIBUJO3:
iDibujo=5;
break;
case TAMANO1:
iTamano++;
break;
break;
case TAMANO2:
iTamano=0.5;
break;
break;
case TAMANO3:
iTamano=iTamano-0.1;
break;
}
glutPostRedisplay();
}
void creacionMenu () {
int menuFondo,menuDibujo,menuPrincipal,menuTamano;
menuFondo= glutCreateMenu(onMenu);
glutAddMenuEntry("Negro",FONDO1);
glutAddMenuEntry("Verde oscuro",FONDO2);
glutAddMenuEntry("Azul oscuro",FONDO3);
menuDibujo=glutCreateMenu(onMenu);
glutAddMenuEntry("Blanco",DIBUJO1);
glutAddMenuEntry("Verde claro",DIBUJO2);
glutAddMenuEntry("Azul claro",DIBUJO3);
menuTamano=glutCreateMenu(onMenu);
glutAddMenuEntry("GRANDE",TAMANO1);
glutAddMenuEntry("NORMAL",TAMANO2);
glutAddMenuEntry("REDUCIDO",TAMANO3);
menuPrincipal = glutCreateMenu(onMenu);
glutAddSubMenu("Cambiar tamano",menuTamano);
glutAddSubMenu("Color de fondo",menuFondo);
glutAddSubMenu("Color de dibujo",menuDibujo);
glutAttachMenu(GLUT_RIGHT_BUTTON);
}
void ControlTeclado (unsigned char key) {
switch (key) {
case 'o':
xpos=xpos-0.1;
break;
case 'p':
xpos=xpos+0.1;
break;
case 'q':
ypos=ypos+0.1;
break;
case 'a':
ypos=ypos-0.1;
break;
}
glutPostRedisplay();
}
void display() {
float colores [6] [3] = {
{0.00f,0.00f,0.00f}, // 0-negro
{0.06f,0.25f,0.13f}, // 1-verde oscuro
{0.10f,0.07f,0.33f}, // 2-azul oscuro
{1.00f,1.00f,1.00f}, // 3-blanco
{0.12f,0.50f,0.26f}, // 4-verde claro
{0.20f,0.14f,0.66f}, // 5-azul claro
};
glTranslatef(xpos,ypos,0.0f);
glClearColor(colores[iFondo][0],colores[iFondo][1],colores[iFondo][2],1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(colores[iDibujo][0],colores[iDibujo][1],colores[iDibujo][2]);
glutWireTeapot(iTamano);
xpos=0.0;
ypos=0.0;
glFlush();
glutSwapBuffers();
}
int main (int argc,char** argv) {
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(700,700);
glutInitWindowPosition(200,200);
glutCreateWindow("Ejercicio 3 ejemplo menus");
glutDisplayFunc(display);
creacionMenu();
glutKeyboardFunc(ControlTeclado);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
EJERCICIO 4
ENUNCIADO
Modificar el ejercicio 3 para que el menu incluya la opcion de cambiar el tamano de la tetera. Tendra las opciones de agrandar , normal y reducir tamano.
FIGURA
CODIGO FUENTE
#include <stdio.h>
#include <stdlib.h>
#include <GL/glx.h> /* this includes the necessary X headers */
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <X11/X.h> /* X11 constant (e.g. TrueColor) */
#include <X11/keysym.h>
int iFondo=0;
int iDibujo=3;
float iTamano=0.5;
typedef enum {FONDO1,FONDO2,FONDO3,DIBUJO1,DIBUJO2,DIBUJO3,TAMANO1,TAMANO2,TAMANO3}
opcionesMenu;
void onMenu (int opcion) {
switch (opcion) {
case FONDO1:
iFondo=0;
break;
case FONDO2:
iFondo=1;
break;
case FONDO3:
iFondo=2;
break;
case DIBUJO1:
iDibujo=3;
break;
case DIBUJO2:
iDibujo=4;
break;
case DIBUJO3:
iDibujo=5;
break;
case TAMANO1:
iTamano++;
break;
case TAMANO2:
iTamano=0.5;
break;
case TAMANO3:
iTamano=iTamano-0.1;
break;
}
glutPostRedisplay();
}
void creacionMenu () {
int menuFondo,menuDibujo,menuPrincipal,menuTamano;
menuFondo= glutCreateMenu(onMenu);
glutAddMenuEntry("Negro",FONDO1);
glutAddMenuEntry("Verde oscuro",FONDO2);
glutAddMenuEntry("Azul oscuro",FONDO3);
menuDibujo=glutCreateMenu(onMenu);
glutAddMenuEntry("Blanco",DIBUJO1);
glutAddMenuEntry("Verde claro",DIBUJO2);
glutAddMenuEntry("Azul claro",DIBUJO3);
menuTamano=glutCreateMenu(onMenu);
glutAddMenuEntry("AGRANDAR",TAMANO1);
glutAddMenuEntry("NORMAL",TAMANO2);
glutAddMenuEntry("REDUCIR",TAMANO3);
menuPrincipal = glutCreateMenu(onMenu);
glutAddSubMenu("Color de fondo",menuFondo);
glutAddSubMenu("Color de dibujo",menuDibujo);
glutAddSubMenu("Cambiar tamano",menuTamano);
glutAttachMenu(GLUT_RIGHT_BUTTON);
}
void display() {
float colores [6] [3] = {
{0.00f,0.00f,0.00f}, // 0-negro
{0.06f,0.25f,0.13f}, // 1-verde oscuro
{0.10f,0.07f,0.33f}, // 2-azul oscuro
{1.00f,1.00f,1.00f}, // 3-blanco
{0.12f,0.50f,0.26f}, // 4-verde claro
{0.20f,0.14f,0.66f}, // 5-azul claro
};
glClearColor(colores[iFondo][0],colores[iFondo][1],colores[iFondo][2],1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(colores[iDibujo][0],colores[iDibujo][1],colores[iDibujo][2]);
glutWireTeapot(iTamano);
glFlush();
glutSwapBuffers();
}
int main (int argc,char** argv) {
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(700,700);
glutInitWindowPosition(200,200);
glutCreateWindow("Ejercicio 3 ejemplo menus");
glutDisplayFunc(display);
creacionMenu();
glutMainLoop();
return 0;
}
Modificar el ejercicio 3 para que el menu incluya la opcion de cambiar el tamano de la tetera. Tendra las opciones de agrandar , normal y reducir tamano.
FIGURA
CODIGO FUENTE
#include <stdio.h>
#include <stdlib.h>
#include <GL/glx.h> /* this includes the necessary X headers */
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <X11/X.h> /* X11 constant (e.g. TrueColor) */
#include <X11/keysym.h>
int iFondo=0;
int iDibujo=3;
float iTamano=0.5;
typedef enum {FONDO1,FONDO2,FONDO3,DIBUJO1,DIBUJO2,DIBUJO3,TAMANO1,TAMANO2,TAMANO3}
opcionesMenu;
void onMenu (int opcion) {
switch (opcion) {
case FONDO1:
iFondo=0;
break;
case FONDO2:
iFondo=1;
break;
case FONDO3:
iFondo=2;
break;
case DIBUJO1:
iDibujo=3;
break;
case DIBUJO2:
iDibujo=4;
break;
case DIBUJO3:
iDibujo=5;
break;
case TAMANO1:
iTamano++;
break;
case TAMANO2:
iTamano=0.5;
break;
case TAMANO3:
iTamano=iTamano-0.1;
break;
}
glutPostRedisplay();
}
void creacionMenu () {
int menuFondo,menuDibujo,menuPrincipal,menuTamano;
menuFondo= glutCreateMenu(onMenu);
glutAddMenuEntry("Negro",FONDO1);
glutAddMenuEntry("Verde oscuro",FONDO2);
glutAddMenuEntry("Azul oscuro",FONDO3);
menuDibujo=glutCreateMenu(onMenu);
glutAddMenuEntry("Blanco",DIBUJO1);
glutAddMenuEntry("Verde claro",DIBUJO2);
glutAddMenuEntry("Azul claro",DIBUJO3);
menuTamano=glutCreateMenu(onMenu);
glutAddMenuEntry("AGRANDAR",TAMANO1);
glutAddMenuEntry("NORMAL",TAMANO2);
glutAddMenuEntry("REDUCIR",TAMANO3);
menuPrincipal = glutCreateMenu(onMenu);
glutAddSubMenu("Color de fondo",menuFondo);
glutAddSubMenu("Color de dibujo",menuDibujo);
glutAddSubMenu("Cambiar tamano",menuTamano);
glutAttachMenu(GLUT_RIGHT_BUTTON);
}
void display() {
float colores [6] [3] = {
{0.00f,0.00f,0.00f}, // 0-negro
{0.06f,0.25f,0.13f}, // 1-verde oscuro
{0.10f,0.07f,0.33f}, // 2-azul oscuro
{1.00f,1.00f,1.00f}, // 3-blanco
{0.12f,0.50f,0.26f}, // 4-verde claro
{0.20f,0.14f,0.66f}, // 5-azul claro
};
glClearColor(colores[iFondo][0],colores[iFondo][1],colores[iFondo][2],1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(colores[iDibujo][0],colores[iDibujo][1],colores[iDibujo][2]);
glutWireTeapot(iTamano);
glFlush();
glutSwapBuffers();
}
int main (int argc,char** argv) {
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(700,700);
glutInitWindowPosition(200,200);
glutCreateWindow("Ejercicio 3 ejemplo menus");
glutDisplayFunc(display);
creacionMenu();
glutMainLoop();
return 0;
}
sábado, 26 de noviembre de 2016
Ejercicio 3
ENUNCIADO
Ejemplo de creacion de menus. Este programa tendra un menu con dos submenus. Estos permitiran elegir el color de fondo y el del dibujo. Para activar el menu principal bastara con hacer clic en el boton derecho del mouse.
FIGURA
CODIGO
#include <stdio.h>
#include <stdlib.h>
#include <GL/glx.h> /* this includes the necessary X headers */
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <X11/X.h> /* X11 constant (e.g. TrueColor) */
#include <X11/keysym.h>
int iFondo=0;
int iDibujo=3;
typedef enum {FONDO1,FONDO2,FONDO3,DIBUJO1,DIBUJO2,DIBUJO3}
opcionesMenu;
void onMenu (int opcion) {
switch (opcion) {
case FONDO1:
iFondo=0;
break;
case FONDO2:
iFondo=1;
break;
case FONDO3:
iFondo=2;
break;
case DIBUJO1:
iDibujo=3;
break;
case DIBUJO2:
iDibujo=4;
break;
case DIBUJO3:
iDibujo=5;
break;
}
glutPostRedisplay();
}
void creacionMenu () {
int menuFondo,menuDibujo,menuPrincipal;
menuFondo= glutCreateMenu(onMenu);
glutAddMenuEntry("Negro",FONDO1);
glutAddMenuEntry("Verde oscuro",FONDO2);
glutAddMenuEntry("Azul oscuro",FONDO3);
menuDibujo=glutCreateMenu(onMenu);
glutAddMenuEntry("Blanco",DIBUJO1);
glutAddMenuEntry("Verde claro",DIBUJO2);
glutAddMenuEntry("Azul claro",DIBUJO3);
menuPrincipal = glutCreateMenu(onMenu);
glutAddSubMenu("Color de fondo",menuFondo);
glutAddSubMenu("Color de dibujo",menuDibujo);
glutAttachMenu(GLUT_RIGHT_BUTTON);
}
void display() {
float colores [6] [3] = {
{0.00f,0.00f,0.00f}, // 0-negro
{0.06f,0.25f,0.13f}, // 1-verde oscuro
{0.10f,0.07f,0.33f}, // 2-azul oscuro
{1.00f,1.00f,1.00f}, // 3-blanco
{0.12f,0.50f,0.26f}, // 4-verde claro
{0.20f,0.14f,0.66f}, // 5-azul claro
};
glClearColor(colores[iFondo][0],colores[iFondo][1],colores[iFondo][2],1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(colores[iDibujo][0],colores[iDibujo][1],colores[iDibujo][2]);
glutWireTeapot(0.5);
glFlush();
glutSwapBuffers();
}
int main (int argc,char** argv) {
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(700,700);
glutInitWindowPosition(200,200);
glutCreateWindow("Ejercicio 3 ejemplo menus");
glutDisplayFunc(display);
creacionMenu();
glutMainLoop();
return 0;
}
Ejercicio 2
ENUNCIADO
Crear una tetera y moverla arrastrandola con el mouse. Manteniendo el boton de este pulsado y arrastrando.
IMAGEN
CODIGO
/*
*Ejemplo de control de mouse.
*/
#include <stdio.h>
#include <stdlib.h>
#include <GL/glx.h> /* this includes the necessary X headers */
#include <GL/gl.h>
#include <GL/glut.h>
#include <GL/glu.h>
#include <X11/X.h> /* X11 constant (e.g. TrueColor) */
#include <X11/keysym.h>
float alpha,beta;
int x0,y0;
void display () {
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(20.0f,1.0f,1.0f,10.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glColor3f(0.0f,1.0f,1.0f);
gluLookAt(0.0f,0.0f,5.0f,
0.0f,0.0f,0.0f,
0.0f,1.0f,0.0f);
glRotatef(alpha,1.0f,0.0f,0.0f);
glRotatef(beta,0.0,1.0f,0.0f);
glColor3f(0.0f,1.0f,1.0f);
glutWireTeapot(0.5);
glFlush();
glutSwapBuffers();
}
void onMouse (int button,int state, int x,int y) {
if((button==GLUT_LEFT_BUTTON)&(state==GLUT_DOWN)) {
x0=x;
y0=y;
}
}
void onMotion (int x,int y) {
alpha=(alpha+(y-y0));
beta=(beta+(x-x0));
x0=x;y0=y;
glutPostRedisplay();
}
int main (int argc,char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(800, 400);
glutInitWindowPosition(100,100);
glutCreateWindow("Ejemplo de control de mouse");
glutDisplayFunc(display);
glutMouseFunc(onMouse);
glutMotionFunc(onMotion);
glutMainLoop();
return 0;
}
Crear una tetera y moverla arrastrandola con el mouse. Manteniendo el boton de este pulsado y arrastrando.
IMAGEN
CODIGO
/*
*Ejemplo de control de mouse.
*/
#include <stdio.h>
#include <stdlib.h>
#include <GL/glx.h> /* this includes the necessary X headers */
#include <GL/gl.h>
#include <GL/glut.h>
#include <GL/glu.h>
#include <X11/X.h> /* X11 constant (e.g. TrueColor) */
#include <X11/keysym.h>
float alpha,beta;
int x0,y0;
void display () {
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(20.0f,1.0f,1.0f,10.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glColor3f(0.0f,1.0f,1.0f);
gluLookAt(0.0f,0.0f,5.0f,
0.0f,0.0f,0.0f,
0.0f,1.0f,0.0f);
glRotatef(alpha,1.0f,0.0f,0.0f);
glRotatef(beta,0.0,1.0f,0.0f);
glColor3f(0.0f,1.0f,1.0f);
glutWireTeapot(0.5);
glFlush();
glutSwapBuffers();
}
void onMouse (int button,int state, int x,int y) {
if((button==GLUT_LEFT_BUTTON)&(state==GLUT_DOWN)) {
x0=x;
y0=y;
}
}
void onMotion (int x,int y) {
alpha=(alpha+(y-y0));
beta=(beta+(x-x0));
x0=x;y0=y;
glutPostRedisplay();
}
int main (int argc,char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(800, 400);
glutInitWindowPosition(100,100);
glutCreateWindow("Ejemplo de control de mouse");
glutDisplayFunc(display);
glutMouseFunc(onMouse);
glutMotionFunc(onMotion);
glutMainLoop();
return 0;
}
EJERCICIO PRIMERO OPENGL
Vamos a hacer un programa en opengl que muestra una esfera verde y la mueve con el teclado ademas cambia de tamaño con las teclas.
El codigo es el siguiente:
/* A simple program to show how to set up an X window for OpenGL rendering.
* X86 compilation: gcc -o -L/usr/X11/lib main main.c -lGL -lX11
* X64 compilation: gcc -o -L/usr/X11/lib64 main main.c -lGL -lX11
*/
/* Muestra una esfera verde que se mueve con teclado y que se puede variar su
* tamano.
*/
#include <stdio.h>
#include <stdlib.h>
#include <GL/glx.h> /* this includes the necessary X headers */
#include <GL/gl.h>
#include <GL/glut.h>
#include <GL/glu.h>
#include <X11/X.h> /* X11 constant (e.g. TrueColor) */
#include <X11/keysym.h>
GLfloat xpos=0, zpos=0, radio=0.2;
/* Rutinas de Render (Dibujado) */
void DibujarMundo( ){
glMatrixMode(GL_PROJECTION);
//glLoadIdentity();
//gluPerspective(5,1,-100,50);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glColor4f(0.0, 0.0, 0.0,1.0);
/*
........
........
esta rutina dibujaría todos los polígonos que componen
nuestro mundo virtual !
........
........
*/
}
void Dibujar( ){
/* Dibujo el mundo que me rodea */
DibujarMundo( );
/* Representaré a mi personaje con una esfera amarilla */
/* Activo el color amarillo */
glLoadIdentity();
glColor4f(0.0, 1.0, 0.0,1.0);
glScalef(0.3,0.3,0.3);
glRotatef(180,0.0,0.0,1.0);
/* Las funciones referidas a matrices que se observan las comentaré
ampliamente en el siguiente capítulo, no os preocupéis por ellas */
glPushMatrix();
/* Me trasladó a la posición concreta en el mundo */
glTranslatef(xpos, zpos,0.0);
/* Dibujo una esfera de radio 2 unidades, y dividida en 16 trozos */
glutSolidSphere(radio, 16, 16);
glPopMatrix();
/* Esta función la explico más adelante en este capítulo */
glutSwapBuffers( );
}
/* Rutina de control del teclado */
void ControlTeclado(unsigned char key,int x,int y ){
/* Según la tecla pulsada incremento una u otra variable de movimiento */
switch(key){
case 'o':
xpos++;
break;
case 'p':
xpos--;
break;
case 'a':
zpos++;
break;
case 'q':
zpos--;
break;
case 'g':
radio++;
break;
case 'b':
radio=0.3;
break;
case 'v':
radio=radio-0.1;
break;
}
/* Le digo a OpenGL que dibuje de nuevo cuando pueda */
glutPostRedisplay( );
}
/* Función MAIN del programa */
int main(int argc, char** argv){
int id;
/* Definición típica de la ventana de visualización */
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(800, 400);
glutInitWindowPosition(100,100);
id=glutCreateWindow("Ejemplo de control de movimiento");
/* Definición de los Callbacks que controlaremos */
/* Cuando haya que dibujar llamaré a ... */
glutDisplayFunc(Dibujar);
/* Cuando el usuario pulse una tecla llamaré a ... */
glutKeyboardFunc(ControlTeclado);
/* Cuando no esté haciendo nada también dibujaré ... */
glutIdleFunc(Dibujar);
glutMainLoop( );
return 0;
}
Vamos a hacer un programa en opengl que muestra una esfera verde y la mueve con el teclado ademas cambia de tamaño con las teclas.
El codigo es el siguiente:
/* A simple program to show how to set up an X window for OpenGL rendering.
* X86 compilation: gcc -o -L/usr/X11/lib main main.c -lGL -lX11
* X64 compilation: gcc -o -L/usr/X11/lib64 main main.c -lGL -lX11
*/
/* Muestra una esfera verde que se mueve con teclado y que se puede variar su
* tamano.
*/
#include <stdio.h>
#include <stdlib.h>
#include <GL/glx.h> /* this includes the necessary X headers */
#include <GL/gl.h>
#include <GL/glut.h>
#include <GL/glu.h>
#include <X11/X.h> /* X11 constant (e.g. TrueColor) */
#include <X11/keysym.h>
GLfloat xpos=0, zpos=0, radio=0.2;
/* Rutinas de Render (Dibujado) */
void DibujarMundo( ){
glMatrixMode(GL_PROJECTION);
//glLoadIdentity();
//gluPerspective(5,1,-100,50);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glColor4f(0.0, 0.0, 0.0,1.0);
/*
........
........
esta rutina dibujaría todos los polígonos que componen
nuestro mundo virtual !
........
........
*/
}
void Dibujar( ){
/* Dibujo el mundo que me rodea */
DibujarMundo( );
/* Representaré a mi personaje con una esfera amarilla */
/* Activo el color amarillo */
glLoadIdentity();
glColor4f(0.0, 1.0, 0.0,1.0);
glScalef(0.3,0.3,0.3);
glRotatef(180,0.0,0.0,1.0);
/* Las funciones referidas a matrices que se observan las comentaré
ampliamente en el siguiente capítulo, no os preocupéis por ellas */
glPushMatrix();
/* Me trasladó a la posición concreta en el mundo */
glTranslatef(xpos, zpos,0.0);
/* Dibujo una esfera de radio 2 unidades, y dividida en 16 trozos */
glutSolidSphere(radio, 16, 16);
glPopMatrix();
/* Esta función la explico más adelante en este capítulo */
glutSwapBuffers( );
}
/* Rutina de control del teclado */
void ControlTeclado(unsigned char key,int x,int y ){
/* Según la tecla pulsada incremento una u otra variable de movimiento */
switch(key){
case 'o':
xpos++;
break;
case 'p':
xpos--;
break;
case 'a':
zpos++;
break;
case 'q':
zpos--;
break;
case 'g':
radio++;
break;
case 'b':
radio=0.3;
break;
case 'v':
radio=radio-0.1;
break;
}
/* Le digo a OpenGL que dibuje de nuevo cuando pueda */
glutPostRedisplay( );
}
/* Función MAIN del programa */
int main(int argc, char** argv){
int id;
/* Definición típica de la ventana de visualización */
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(800, 400);
glutInitWindowPosition(100,100);
id=glutCreateWindow("Ejemplo de control de movimiento");
/* Definición de los Callbacks que controlaremos */
/* Cuando haya que dibujar llamaré a ... */
glutDisplayFunc(Dibujar);
/* Cuando el usuario pulse una tecla llamaré a ... */
glutKeyboardFunc(ControlTeclado);
/* Cuando no esté haciendo nada también dibujaré ... */
glutIdleFunc(Dibujar);
glutMainLoop( );
return 0;
}
Suscribirse a:
Comentarios (Atom)