Práctica 4

1. Complie y corra el código que generó en el cuestionario previo.

#include

GLfloat brazo = 0.0f;
GLfloat antebrazo = 0.0f;
GLfloat dedo1 = 0.0f;
GLfloat dedo2 = 0.0f;

void reshape(int width, int height){
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0f, (GLfloat)width/(GLfloat)height, 1.0f, 20.0f);
glMatrixMode(GL_MODELVIEW);
}

void cuadrado(){
glBegin(GL_LINE_STRIP);
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);
glVertex3f(-0.5,0.5,-0.5);
glEnd();
}

void cubo(){
cuadrado();
glPushMatrix();
glTranslatef(0.0f, 0.0f, 1.0f);
cuadrado();
glPopMatrix();
glPushMatrix();
glRotatef(-90, 1.0f, 0.0f, 0.0f);
cuadrado();
glPopMatrix();
glPushMatrix();
glRotatef(90, 1.0f, 0.0f, 0.0f);
cuadrado();
glPopMatrix();
}

// antebrazo
void fun_antebrazo(){
glPushMatrix();
glTranslatef(1.0f, 0.0f, 0.0f);
glScalef(2.0f, 2.0f, 1.0f);
cubo();
glPopMatrix();
}
// brazo.
void fun_brazo(){
glPushMatrix();
glTranslatef(2.0f, 0.0f, 0.0f);
glScalef(4.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();
}
// dedo.
void fun_dedo(){
glPushMatrix();
glTranslatef(0.5f, 0.0f, 0.0f);
glScalef(1.0f, 0.25f, 1.0f);
cubo();
glPopMatrix();
}
//brazo_robot
void brazo_robot(float antebrazo, float brazo, float dedo1, float dedo2){
glPushMatrix();
glTranslatef(0.0f, 0.0f, 0.0f);
glRotatef(antebrazo, 0.0f, 0.0f, 1.0f);
fun_antebrazo();
glPushMatrix();
glTranslatef(1.7f, 0.0f, 0.0f);
glRotatef(brazo, 0.0f, 0.0f, 1.0f);
fun_brazo();
glPushMatrix();
glTranslatef(3.8f, 0.25f, 0.0f);
glRotatef(dedo1, 0.0f, 0.0f, 1.0f);
fun_dedo();
glPopMatrix();
glPushMatrix();
glTranslatef(3.8f, -0.25f, 0.0f);
glRotatef(dedo2, 0.0f, 0.0f, 1.0f);
fun_dedo();
glPopMatrix();
glPopMatrix();
glPopMatrix();
}

void display(){
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(.9,0.8,0.8);
glLoadIdentity();
gluLookAt (0.0, 1.0, -11.0, 2.0, 0.0, 5.0, 0.0, 2.0, 0.0);
glTranslatef(0.0f, 0.0f, 0.0f);
brazo_robot(antebrazo,brazo,dedo1,dedo2);
glFlush();
glutSwapBuffers();
}
void init(){
glClearColor(0.5,0.2,0.1,0.5);
glEnable(GL_DEPTH_TEST);
}
void idle() {
display();
}
// eventos del teclado.
void keyboard(unsigned char key, int x, int y){
switch(key)
{
case 'a':
antebrazo=antebrazo+1;
reshape(500,500);
break;
case 's':
antebrazo=antebrazo-1;
reshape(500,500);
break;
case 'd':
brazo=brazo+1;
reshape(500,500);
break;
case 'f':
brazo=brazo-1;
reshape(500,500);
break;
case 'g':
dedo1=dedo1+1;
reshape(500,500);
break;
case 'h':
dedo1=dedo1-1;
reshape(500,500);
break;
case 'j':
dedo2=dedo2+1;
reshape(500,500);
break;
case 'k':
dedo2=dedo2-1;
reshape(500,500);
break;
}
}
int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowPosition(350, 100);
glutInitWindowSize(300, 300);
glutCreateWindow("Brazo Robot");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}


2. Construya una escena en la cual haga:
- 2 braxoz con teneza
- 2 manos
- 4 cubos
- 3 humanoides
A cada objeto aplique juegos diferentes de transformaciones.

#include

void reshape(int width, int height){
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(55.0f, (GLfloat)width/(GLfloat)height, 0.1, 0);
glMatrixMode(GL_MODELVIEW);
}
void cuadrado(){
glBegin(GL_LINE_STRIP);
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);
glVertex3f(-0.5,0.5,-0.5);
glEnd();
}
void cubo(){
cuadrado();
glPushMatrix();
glTranslatef(0.0f, 0.0f, 1.0f);
cuadrado();
glPopMatrix();
glPushMatrix();
glRotatef(-90, 1.0f, 0.0f, 0.0f);
cuadrado();
glPopMatrix();
glPushMatrix();
glRotatef(90, 1.0f, 0.0f, 0.0f);
cuadrado();
glPopMatrix();
}
// Partes del Humanoide
void cabeza(){
glPushMatrix();
glTranslatef(0.0f, 6.75f, 0.0f);
glScalef(2.0f, 1.5f, 2.0f);
cubo();
glPopMatrix();
}
void cuello(){
glPushMatrix();
glTranslatef(0.0f, 5.75f, 0.0f);
glScalef(1.0f, 0.5f, 0.5f);
cubo();
glPopMatrix();
}
void torax(){
glPushMatrix();
glTranslatef(0.0f, 4.0f, 0.0f);
glScalef(6.0f, 3.0f, 4.0f);
cubo();
glPopMatrix();
}
void brazos_completos(){
glPushMatrix();
glTranslatef(4.0f, 4.0f, 0.0f);
glScalef(2.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();

glPushMatrix();
glTranslatef(6.0f, 4.0f, 0.0f);
glScalef(2.0f, 1.5f, 1.0f);
cubo();
glPopMatrix();

glPushMatrix();
glTranslatef(7.25f, 4.0f, 0.0f);
glScalef(0.5f, 0.5f, 1.0f);
cubo();
glPopMatrix();

glPushMatrix();
glTranslatef(-4.0f, 4.0f, 0.0f);
glRotatef(180, 0.0f, 0.0f, 1.0f);
glScalef(2.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();
// Codo Izquierdo
glPushMatrix();
glTranslatef(-6.0f, 4.0f, 0.0f);
glRotatef(180, 0.0f, 0.0f, 1.0f);
glScalef(2.0f, 1.5f, 1.0f);
cubo();
glPopMatrix();
// Nudillo Izquierdo
glPushMatrix();
glTranslatef(-7.25f, 4.0f, 0.0f);
glRotatef(180, 0.0f, 0.0f, 1.0f);
glScalef(0.5f, 0.5f, 0.5f);
cubo();
glPopMatrix();
}
void piernas_completas()
{
// Muslo Derecho
glPushMatrix();
glTranslatef(2.0f, -1.5f, 0.0f);
glScalef(1.0f, 2.0f, 1.5f);
cubo();
glPopMatrix();
// Muslo Izquierdo
glPushMatrix();
glTranslatef(-2.0f, -1.5f, 0.0f);
glScalef(1.0f, 2.0f, 1.5f);
cubo();
glPopMatrix();
// Pierna Derecha
glPushMatrix();
glTranslatef(2.0f, -4.5f, 0.0f);
glScalef(1.4f, 4.0f, 1.5f);
cubo();
glPopMatrix();
// Pierna Izquierda
glPushMatrix();
glTranslatef(-2.0f, -4.5f, 0.0f);
glScalef(1.4f, 4.0f, 1.5f);
cubo();
glPopMatrix();
// Pie Derecho
glPushMatrix();
glTranslatef(2.0f, -7.25f, 0.0f);
glScalef(2.75f, 1.5f, 2.0f);
cubo();
glPopMatrix();
// Pie Izquierdo
glPushMatrix();
glTranslatef(-2.0f, -7.25f, 0.0f);
glScalef(2.75f, 1.5f, 2.0f);
cubo();
glPopMatrix();
}
void cadera(){
glPushMatrix();
glTranslatef(0.0f, 0.0f, 0.0f);
glScalef(6.0f, 1.0f, 3.0f);
cubo();
glPopMatrix();
}
void columna(){
glPushMatrix();
glTranslatef(0.0f, 1.5f, 0.0f);
glScalef(1.0f, 2.0f, 1.0f);
cubo();
glPopMatrix();
}
void humanoide(){
cabeza();
cuello();
torax();
brazos_completos();
columna();
cadera();
piernas_completas();
}
// Mano
void palma(){
glPushMatrix();
glScalef(4.0f, 4.0f, 1.0f);
cubo();
glPopMatrix();
}
void dedo(){
glPushMatrix();
glTranslatef(1.5f, 2.4f, 0.0f);
glScalef(0.80f, 0.80f, 0.5f);
cubo();
glTranslatef(0.0f, 1.0f, 0.0f);
cubo();
glPopMatrix();
}
void dedos_mano(){
glPushMatrix();
dedo();
glTranslatef(-1.0f, 0.0f, 0.0f);
dedo();
glTranslatef(-1.0f, 0.0f, 0.0f);
dedo();
glTranslatef(-1.0f, 0.0f, 0.0f);
dedo();
glPopMatrix();
}
void dedo_gordo(){
glPushMatrix();
glScalef(0.80f, 0.80f, 0.7f);
cubo();
glTranslatef(-0.60f, 0.60f, 0.0f);
cubo();
glTranslatef(-0.60f, 0.60f, 0.0f);
cubo();
glTranslatef(-0.60f, 0.60f, 0.0f);
cubo();
glPopMatrix();
}
void mano(){
glPushMatrix();
palma();
glPopMatrix();
glPushMatrix();
dedos_mano();
glPopMatrix();
glPushMatrix();
glTranslatef(-2.0f, 0.0f, 0.0f);
dedo_gordo();
glPopMatrix();
}
// Brazo Robot
void hombro_robot(){
glPushMatrix();
glScalef(2.0f, 2.0f, 1.0f);
cubo();
glPopMatrix();
}
void brazo_robot(){
glRotatef(25, 0.0f, 0.0f, 1.0f);
glPushMatrix();
glTranslatef(2.85f, 0.0f, 0.0f);
glScalef(4.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();
}
void dedos_robot(){
glPushMatrix();
glTranslatef(5.25f, 0.25f, 0.0f);
glScalef(1.0f, 0.25f, 1.0f);
cubo();
glTranslatef(0.0f, -2.0f, 0.0f);
cubo();
glPopMatrix();
}

void brazo_robot_tenaza(){
glRotatef(-45, 0.0f, 0.0f, 1.0f);
hombro_robot();
brazo_robot();
dedos_robot();
}
void display(){
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.7,0.7,0.7);
glLoadIdentity();
gluLookAt (4.0, 2.0, 20.0, .0, 0.0, 0.0, 0.0, 1.0, 0.0);
// Cubo 1
glPushMatrix();
glTranslatef(-10.0,8.0,0.0);
glScalef (2.0, 2.0, 2.0);
glRotatef(45, 1.0f, 0.0f, 0.0f);
cubo();
glPopMatrix();
// Cubo 2
glPushMatrix();
glTranslatef(-10.0,5.0,0.0);
glScalef (1.5, 1.5, 1.5);
glRotatef(90, 1.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();
// Cubo 3
glPushMatrix();
glTranslatef(-10.0,2.0,0.0);
glScalef (1.0, 1.0, 1.0);
glRotatef(135, 1.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();
// Cubo 4
glPushMatrix();
glTranslatef(-10.0,-1.0,0.0);
glScalef (1.8, 1.8, 1.8);
glRotatef(180, 1.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();
// Humanoide 1
glPushMatrix();
glTranslatef(6.5,4.0,0.0);
glScalef (0.45, 0.45, 0.45);
glRotatef(-10, 0.0f, 0.0f, 1.0f);
humanoide();
glPopMatrix();
// Humanoide 2
glPushMatrix();
glTranslatef(2.0,2.0,0.0);
glScalef (0.25, 0.25, 0.25);
glRotatef(0, 0.0f, 0.0f, 1.0f);
humanoide();
glPopMatrix();
// Humanoide 3
glPushMatrix();
glTranslatef(-3.0,4.0,-0.0);
glScalef (0.50, 0.50, 0.50);
glRotatef(10, 0.0f, 0.0f, 1.0f);
humanoide();
glPopMatrix();
// Mano 1
glPushMatrix();
glTranslatef(-10.0,-6.0,-0.0);
glScalef (0.5, 0.5, 0.5);
glRotatef(20, 0.0f, 0.0f, 1.0f);
mano();
glPopMatrix();
// Mano 2
glPushMatrix();
glTranslatef(-4.0,-4.0,-0.0);
glScalef (0.8, 0.8, 0.8);
glRotatef(15, 0.0f, 1.0f, 0.0f);
mano();
glPopMatrix();
// BrazoRobot 1
glPushMatrix();
glTranslatef(1.0,-4.0,-0.0);
glScalef (0.8, 0.8, 0.8);
glRotatef(-20, 0.0f, 0.0f, 1.0f);
brazo_robot_tenaza();
glPopMatrix();
// BrazoRobot 2
glPushMatrix();
glTranslatef(6.0,-2.0,-0.0);
glScalef (0.6, 0.6, 0.6);
glRotatef(15, 0.0f, 0.0f, 1.0f);
brazo_robot_tenaza();
glPopMatrix();
glFlush();
}
void init(){
glClearColor(0.2,0.4,0.1,0.1);
}

int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(350, 100);
glutInitWindowSize(500, 400);
glutCreateWindow("Escenario");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

Previo Práctica 4

1.¿Que es una escena?
R:- Ensambles de primitivas
-Superficie: Color, Textura, Normales y Normales “truchas”
-Fondo o Ambiente
- Luces: Modelos de iluminación
- Cámara: Proyección

2.¿Como podemos definir una escena jerarquicamente?
R: consiste en dar movimiento a todos los objetos que se encuentren en la escena.

3.¿Describa el funcionamiento y parametros de la funcion
glutSwapBuffers()

void glutSwapBuffers(void);

Realiza un intercambio de buffer en la capa en uso para la ventana actual. Específicamente, hace que el contenido del buffer trasero de la capa en uso se convierta en contenido del buffer frontal. En este paso el contenido del buffer trasero se considera cono undefined o indefinido. La actualización usualmente se realiza durante el re-trazado vertical del monitor, en vez de ser realizado inmediatamente después de llamar a la función glutSwapBuffers. Antes de retornar, esta función realiza un glFlush. Los comandos subsecuentes de OpenGL pueden ser ordenados inmediatamente después de llamar a la función, pero no son ejecutados hasta que el intercambio de buffers se complete.

glutKeyboardFunc()

Uso

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

func.- la nueva función de teclado

Descripción

glutKeyboardFunc dispone la función de telado para la ventan actual. Cuando el usuario teclea en la ventana, cada tecla presionada genera un carácter ASCII el cual generará un una función de teclado. El parámetro tecla es el carácter ASCII generado. El estado de teclas modificadoras como Shift no pueden ser determinadas directamente; su único efecto será al regresar un dato ASCII los parámetros x y y indican la posición de mouse en coordenadas relativas dentro de la ventana cuando la tecla fue presionada. Cuando una nueva ventana es creada, no hay ninguna función de teclado asignada, y todos los caracteres ASCII creados en la ventana serán ignorados.

glutIdleFunc()

Uso: void glutIdleFunc(void (*func)(void));

glutIdleFunc coloca el callback de inactividad global para ser func para que así un programa GLUT pueda realizar procesos continuos de animación cuando el los eventos de sistema de ventana no estén siendo recibidos. Si se habilita, el callback de inactividad se llama continuamente cuando no haya eventos recibidos. La rutina de callback no tiene parámetros. La ventana actual y el menú actual no serán cambiados antes del callback de inactividad. Los programas con ventanas o menús múltiples deben colocar explícitamente la ventana y/o el menú actual y no deberán confiar en su configuración actual.

4.¿Que es el doble buffer (buffer doble)? ¿Para que sirve? ¿Como se declara con GLUT?

R: La animación se logra usando doble buffer, se dibuja algo en el buffer secundario, el que no se ve en pantalla, y luego se intercambia por el de la pantalla, si se hacen pequeños cambios, se logra ver una animación.

Es necesario definir nuestra ventana con doble buffer, esto se logra reemplazando los parámetros de glutInitDisplayMode por GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB , o sea, cambiar el buffer single por un buffer doble.

En la función dibujar, hemos limpiado el buffer de la pantalla, ahora debemos limpiar el buffer depth, el buffer secundario, para que no tenga cosas previamente dibujadas. Esto se logra usando glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) en la función dibujar.

Y para finalizar, al final de nuestra función dibujar hay que intercambiar los buffer, del secundario al primario, esto se logra con glutSwapBuffers();

5.¿Que es un "function callback" (llamada a funcion) Pista: Sirve para manejos de eventos.

R: Una función Callback será llamada por GLUT para hacer alguna operación específica cada vez que se produzca un evento.

Reporte Práctica 3

Escriba el código para dibujar una mano

#include
void reshape(int width, int height)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-6,4, -3, 5, 0.5, 80);
glMatrixMode(GL_MODELVIEW);
}
void cuadrado()
{
glBegin(GL_LINE_STRIP);
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);
glVertex3f(-0.5,0.5,-0.5);
glEnd();
}
void cubo()
{
cuadrado();
glPushMatrix();
glTranslatef(0.0f, 0.0f, 1.0f);
cuadrado();
glPopMatrix();
glPushMatrix();
glRotatef(-90, 1.0f, 0.0f, 0.0f);
cuadrado();
glPopMatrix();
glPushMatrix();
glRotatef(90, 1.0f, 0.0f, 0.0f);
cuadrado();
glPopMatrix();
}
void palma()
{
glPushMatrix();
glScalef(4.0f, 4.0f, 1.0f);
cubo();
glPopMatrix();
}
void dedo()
{
glPushMatrix();
glTranslatef(1.5f, 2.4f, 0.0f);
glScalef(0.80f, 0.80f, 0.5f);
cubo();
glTranslatef(0.0f, 1.0f, 0.0f);
cubo();
glPopMatrix();
}
void dedos_mano()
{
glPushMatrix();
dedo();
glTranslatef(-1.0f, 0.0f, 0.0f);
dedo();
glTranslatef(-1.0f, 0.0f, 0.0f);
dedo();
glTranslatef(-1.0f, 0.0f, 0.0f);
dedo();
glPopMatrix();
}
void dedo_gordo()
{
glPushMatrix();
glScalef(0.80f, 0.80f, 0.7f);
cubo();
glTranslatef(-0.60f, 0.60f, 0.0f);
cubo();
glTranslatef(-0.60f, 0.60f, 0.0f);
cubo();
glTranslatef(-0.60f, 0.60f, 0.0f);
cubo();
glPopMatrix();
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(3,1,1);
glLoadIdentity();
gluLookAt (0.0,0.0,5.0,0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glPushMatrix();
palma();
glPopMatrix();
glPushMatrix();
dedos_mano();
glPopMatrix();
glPushMatrix();
glTranslatef(-2.0f, 0.0f, 0.0f);
dedo_gordo();
glPopMatrix();
glFlush();
}
void init()
{
glClearColor(0,0,0,0);
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(300, 80);
glutInitWindowSize(400, 400);
glutCreateWindow("Mano Robot");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

Práctica 3

1.- Compile y ejecute el código que escribió en el reporte previo.

/*Humanoide parametrizado*/
#include

void init(void){
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}
void cubod(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();
}
/*Rotaciones del brazo derecho*/
static int brazderrot = 0;
static int angbrazder = 0;
static int codderrot = 0;
static int angcododer = 0;
/*cabeza*/
void cabeza (float x){
glPushMatrix();
glTranslatef(0.0,2.0,0.0);
glRotatef(x,0.0,0.1,0.0);
cubohueco();
glPopMatrix();
}
/*Torso.*/
void tronco (float x, float y, float z){
glTranslatef(x,y,z);
glRotatef((GLfloat)torsorot,0.0,1.0,0.0);
glPushMatrix();
glScalef (2.0, 3.0, 1.0);
cubod();
glPopMatrix();
}
/*brazo derecho*/
void brazoder (int y, int z){
glPushMatrix();
glTranslatef(2.0,1.25,0.0);
glTranslatef(-1.0,0.0,0.0);
/*eje en el cual va a girar el brazo.*/
switch(y){
case 0:
glRotatef((GLfloat)angbrazder, 1.0, 0.0, 0.0);
break;
case 1:
glRotatef((GLfloat)angbrazder, 0.0, 1.0, 0.0);
break;
case 2:
glRotatef((GLfloat)angbrazder, 0.0, 0.0, 1.0);
break;
default:
break;
}
glPushMatrix();
glTranslatef(1.0,0.0,0.0);
glScalef(2.0,0.5,1.0);
cubod();
glPopMatrix();
/*antebrazo derecho*/
glTranslatef(3.0,0.0,0.0);
glTranslatef(-1.0,0.0,0.0);
/*eje sobre el cuál girará el antebrazo derecho*/
switch(z){
case 0:
glRotatef((GLfloat)angcododer, 1.0, 0.0, 0.0);
break;
case 1:
glRotatef((GLfloat)angcododer, 0.0, 1.0, 0.0);
break;
case 2:
glRotatef((GLfloat)angcododer, 0.0, 0.0, 1.0);
break;
default:
break;
}
glPushMatrix();
glTranslatef(1.0,0.0,0.0);
glScalef(2.0,1.0,1.0);
cubod();
glPopMatrix();
/*mano derecha*/
glTranslatef(2.25,0.0,0.0);
glPushMatrix();
glScalef(0.5,0.5,1.0);
cubod();
glPopMatrix();
glPopMatrix();
}
void brazoizq (float x, int y){
glPushMatrix();
glTranslatef(-2.0,1.25,0.0);
/*eje sobre el cuál girará el brazo izquierdo*/
switch(y){
case 0:
glRotatef((GLfloat)angbrazizq, 1.0, 0.0, 0.0);
break;
case 1:
glRotatef((GLfloat)angbrazizq, 0.0, 1.0, 0.0);
break;
case 2:
glRotatef((GLfloat)angbrazizq, 0.0, 0.0, 1.0);
break;
default:
break;
}
glPushMatrix();
glScalef(2.0,0.5,1.0);
cubod();
glPopMatrix();
/*antebrazo izquierdo*/
glTranslatef(-2.0,0.0,0.0);
glPushMatrix();
glScalef(2.0,1.0,1.0);
cubod();
glPopMatrix();
/*mano izquierdo*/
glTranslatef(-1.25,0.0,0.0);
glPushMatrix();
glScalef(0.5,0.5,1.0);
cubod();
glPopMatrix();
glPopMatrix();
}
void pierder (float x, int y){
glPushMatrix();
glTranslatef(0.6,-2.25,0.0);
/*giro de la pierna derecha*/
switch(y){
case 0:
glRotatef((GLfloat)angpierder, 1.0, 0.0, 0.0);
break;
case 1:
glRotatef((GLfloat)angpierder, 0.0, 1.0, 0.0);
break;
case 2:
glRotatef((GLfloat)angpierder, 0.0, 0.0, 1.0);
break;
default:
break;
}
glPushMatrix();
glScalef(0.75,1.5,1.0);
cubod();
glPopMatrix();
/*pantorrilla derecha*/
glTranslatef(0.0,-1.5,0.0);
glPushMatrix();
glScalef(0.6,1.5,1.0);
cubod();
glPopMatrix();
/*pie derecho*/
glTranslatef(0.25,-0.85,0.0);
glPushMatrix();
glScalef(1.5,0.25,1.0);
cubod();
glPopMatrix();
glPopMatrix();/*pierna derecha completa*/
}
void pierizq (float x, int y){
glPushMatrix();
glTranslatef(-0.6,-2.25,0.0);
/*Switch que indica sobre qué eje va a girar la pierna izquierda.*/
switch(y){
case 0:
glRotatef((GLfloat)angpierizq, 1.0, 0.0, 0.0);
break;
case 1:
glRotatef((GLfloat)angpierizq, 0.0, 1.0, 0.0);
break;
case 2:
glRotatef((GLfloat)angpierizq, 0.0, 0.0, 1.0);
break;
default:
break;
}
glPushMatrix();
glScalef(0.75,1.5,1.0);
cubod();
glPopMatrix();
/*pantorrilla izquierda*/
glTranslatef(0.0,-1.5,0.0);
glPushMatrix();
glScalef(0.6,1.5,1.0);
cubod();
glPopMatrix();
/*pie izquierdo*/
glTranslatef(-0.25,-0.85,0.0);
glPushMatrix();
glScalef(1.5,0.25,1.0);
cubod();
glPopMatrix();
glPopMatrix();/*pierna izquierda completa*/
}
void display (void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glLoadIdentity (); /* clear the matrix */
gluLookAt (0.0, 0.0, 9.5, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glPushMatrix();
/*torso*/
tronco(0.0,1.5,0.0);
/*cara*/
cabeza(cuellorot);
/*brazo derecho*/
brazoder(brazderrot, codderrot);
/*brazo izquierdo*/
brazoizq(angbrazizq,brazizqrot);
/*muslo derecho*/
pierder(angpierder,pierderrot);
/*muslo izquierdo*/
pierizq(angpierizq,pierizqrot);
glPopMatrix();/*humanoide completo*/
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);
}
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 't':
torsorot = (torsorot + 5)%360;
glutPostRedisplay();
break;
case 'j':
brazderrot = brazderrot + 1;
angbrazder = 0;
angcododer = angcododer-5;
if(brazderrot==3){
brazderrot = 0;
}
case 'k':
codderrot = codderrot + 1;
angcododer = 0;
angbrazder = angbrazder-5;
if(codderrot==3){
codderrot = 0;
}
case 'd':
angbrazder = (angbrazder + 5)%180;
glutPostRedisplay();
break;
case 's':
angcododer = (angcododer + 5)%180;
glutPostRedisplay();
break;
case 27:
break;
}
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (80, 200);
glutCreateWindow ('Humanoide jerárquico');
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

2.- Cree de manera jerárquica un brazo robot de dos eslabones, construida a partir de un cubo deformado por escalamiento, función brazorobot() en objetos.h

#include
void reshape(int width, int height)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-12,12, -12, 12, 0.001, 100);
glMatrixMode(GL_MODELVIEW);
}
void cuadrado()
{
glBegin(GL_LINE_STRIP);
glVertex3f(-1.5,1.5,-1.5);
glVertex3f(-1.5,-1.5,-1.5);
glVertex3f(1.5,-1.5,-1.5);
glVertex3f(1.5,1.5,-1.5);
glVertex3f(-1.5,1.5,-1.5);
glEnd();
}
void cubo()
{
cuadrado();
glPushMatrix();
glTranslatef(0.0f, 0.0f, 0.0f);
cuadrado();
glPopMatrix();
glPushMatrix();
glRotatef(-90, 0.0f, 0.0f, 1.0f);
cuadrado();
glPopMatrix();
glPushMatrix();
glRotatef(90, 0.0f, 0.0f, 1.0f);
cuadrado();
glPopMatrix();
}
void hombro()
{
glPushMatrix();
glScalef(1.5f, 1.5f, 0.5f);
cubo();
glPopMatrix();
}
void brazo()
{
glPushMatrix();
glRotatef(10, 0.0f, 0.0f, 1.0f);
glTranslatef(6.0f, -0.5f, 0.0f);
glScalef(3.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();
}
void brazo_robot()
{
hombro();
brazo();
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(3,1,3);
glLoadIdentity();
glRotatef(0, 0.0f, 0.0f, 1.0f);
brazo_robot();
glFlush();
}
void init()
{
glClearColor(-6,0,1,-2);
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(500, 100);
glutInitWindowSize(400, 400);
glutCreateWindow("Brazo Robot");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

3.- Agregue dos eslabones más al brazo robot a manera de una tenaza y cree la función brazo robot con tenaza() en objetos.h.

#include
void reshape(int width, int height)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-12,12, -12, 12, 0.001, 100);
glMatrixMode(GL_MODELVIEW);
}
void cuadrado()
{
glBegin(GL_LINE_STRIP);
glVertex3f(-0.9,0.9,-0.9);
glVertex3f(-0.9,-0.9,-0.9);
glVertex3f(0.9,-0.9,-0.9);
glVertex3f(0.9,0.9,-0.9);
glVertex3f(-0.9,0.9,-0.9);
glEnd();
}
void cubo()
{
cuadrado();
glPushMatrix();
cuadrado();
glPopMatrix();
glPushMatrix();
cuadrado();
glPopMatrix();
glPushMatrix();
cuadrado();
glPopMatrix();
}
void hombro()
{
glPushMatrix();
glScalef(2.0f, 2.0f, 1.0f);
cubo();
glPopMatrix();
}
void brazo()
{
glPushMatrix();
glTranslatef(4.5f, 0.0f, 0.0f);
glScalef(4.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();
}
void dedos()
{
glPushMatrix();
glTranslatef(9.0f, 0.25f, 0.0f);
glScalef(1.0f, 0.25f, 1.0f);
cubo();
glTranslatef(0.0f, -2.0f, 0.0f);
cubo();
glPopMatrix();
}
void brazo_robot_tenaza()
{
hombro();
brazo();
dedos();
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1,0,0);
glLoadIdentity();
brazo_robot_tenaza();
glFlush();
}
void init()
{
glClearColor(-10,2,-10,0);
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(500, 100);
glutInitWindowSize(300, 200);
glutCreateWindow("Brazo con un par de tenazas");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

Previo Práctica 3

Previo 3

1.- ¿Qué es una composición de transformaciones?
R: Una matriz de transformación M 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 sucesivas que modifiquen la matriz que describe dicho objeto (esto es denominado composición 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 que?
R: El producto de dos matrices es una herramienta que nos permite conectar dos transformaciones. Aplicar dos o más transformaciones sucesivas a un punto es equivalente a aplicar a ese punto el producto de las matrices de las respectivas transformaciones. Las transformaciones no tienen por que ser del mismo tipo, se puede mezclar transformaciones. Esto es posible porque todas ellas se representan mediante el mismo formalismo matemático: la multiplicación de matrices. Debido a que la multiplicación de matrices no es conmutativa, hay que tener cuidado con el orden en que se componen las transformaciones. El orden de composición de las transformaciones es el opuesto al orden de aplicación de estas.

3.- ¿Es lo mismo:

glRotatef(30.0,1.0,0.0,0.0);

glTranslatef(1,1,1);

glScale(2.0,2.0,2.0);

cubo();

que:

cubo();

glRotatef(30.0,1.0,0.0,0.0);

glTranslatef(1,1,1);

glScale(2.0,2.0,2.0);

o que:

glScale(2.0,2.0,2.0);

glRotatef(30.0,1.0,0.0,0.0);

glTranslatef(1,1,1);

cubo();

¿Por qué?

R: Las transformaciones se almacenan como matrices, OpenGL utiliza una pila de matrices para recordar situaciones anteriores a las transformaciones aplicadas. La matriz actual es siempre la que está en la posición más elevada de la pila.

4.- ¿Qué es un modelo jerárquico?
R: Un modelo jerárquico describe la forma de un objeto físico o matemático por medios de conceptos geométricos. El modelado jerárquico es la construcción o uso de modelos geométricos. Los modelos jerárquicos se utilizan en computación gráfica, diseño auxiliado por computadora y manufactura y pueden aplicarse a muchos campos, tales como el procesamiento de imágenes de medicina.

http://computacion.cs.cinvestav.mx/~sabel/graficacion/tarea_6/tarea6.html

Reporte Práctica 2

1.- Escribe un programa en el cuál se dibuje un cuadrado. Utilizando llamadas al cuadrado y aplicando rotaciones y traslaciones, dibuje un cubo. A partir del cubo y transformándolo construya un humanoide

#include
void init(void){
glClearColor (0.3, 0.3, 0.3, 0.9);
glShadeModel (GL_FLAT);
}
void display(void){
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0.4, 0.9, 0.4);
glLoadIdentity ();
gluLookAt (2.5, 1.0, 10, 0.5, 0.0, 2.5, 1.0, 9.0, 1.0);
glPushMatrix();
glScalef (2.0, 3.0, 1.0);
glTranslatef(0.0,0.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*Codigo para la cabeza*/
glPushMatrix();
glTranslatef(0.0,3.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*A continuación se dibuja el brazo derecho*/
glPushMatrix();
glScalef (2.0, 0.5, 1.0);
glTranslatef(1.0,5.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*Ahora el antebrazo derecho*/
glPushMatrix();
glScalef (2.0, 1.0, 1.0);
glTranslatef(2.0,2.75,0.0);
glutWireCube(1.0);
glPopMatrix();
/*Seguimos con la mano derecha*/
glPushMatrix();
glScalef (0.5, 0.5, 1.0);
glTranslatef(10.5,5.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*Nos vamos con el brazo izquierdo*/
glPushMatrix();
glScalef (2.0, 0.5, 1.0);
glTranslatef(-1.0,5.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*Códifo para el antebrazo izquierdo*/
glPushMatrix();
glScalef (-2.0, 1.0, 1.0);
glTranslatef(2.0,2.75,0.0);
glutWireCube(1.0);
glPopMatrix();
/*Código para desplegar la mano izquierda*/
glPushMatrix();
glScalef (0.5, 0.5, 1.0);
glTranslatef(-10.5,5.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*Código para dibujar el muslo derecho*/
glPushMatrix();
glScalef (0.5, 2.5, 1.0);
glTranslatef(1.5,-0.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*la pantorrilla derecha*/
glPushMatrix();
glScalef (1.0, 2.5, 1.0);
glTranslatef(0.75,-1.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*pie derecho*/
glPushMatrix();
glScalef (1.75, 0.5, 1.0);
glTranslatef(0.635,-10.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*muslo izquierdo*/
glPushMatrix();
glScalef (0.5, 2.5, 1.0);
glTranslatef(-1.5,-0.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*pantorrilla izquierda*/
glPushMatrix();
glScalef (1.0, 2.5, 1.0);
glTranslatef(-0.75,-1.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*Y por último el código para dibujar el pie izquierdo*/
glPushMatrix();
glScalef (1.75, 0.5, 1.0);
glTranslatef(-0.635,-10.5,0.0);
glutWireCube(1.0);
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);
}
void keyboard(unsigned char key, int x, int y){
switch (key) {
case 27:
break;
}}
int main(int argc, char** argv){
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (300, 50);
glutCreateWindow ("Humanoide");
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

Práctica 2

1.- Cargue, compile y ejecute el código que escribió en el previo.

#include
void dibuja() {
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_TRIANGLE_STRIP);
glColor3f(0.1, 0.9, 0.1);
glVertex3f(0, 2.3, 0);
glColor3f(0.1, 0.9, 0.1);
glVertex3f(-1.6, 0, 1.6);
glColor3f(0.1, 0.2, 0.1);
glVertex3f(1.6, -1, 3);
glColor3f(0.1, 0.2, 0.1);
glVertex3f(-3, -1, -1.6);
glColor3f(0.1, 0.1, 0.1);
glVertex3f(0, 2.3, 0);
glColor3f(0.1, 0.1, 0.1);
glVertex3f(-1.6, 0, 1.6);
glEnd();
glFlush();
}
glClearColor(0, 0, 0, 1.0);
glColor3f(1.0, 1.0, 1.0);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-2, 2, -1.5, 1.5, 1, 40);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0, 0, -4);
glRotatef(45, 20, 0, 0);
glRotatef(45, 0, 20, 0);
}
int main(int argc, char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(480, 30);
glutInitWindowSize(300, 300);
glutCreateWindow("Tetraedro");
glutDisplayFunc(dibuja);
inicio();
glutMainLoop();
}

2.- Busque la referencia en línea a la API de GLUT y escriba programas que le permita ver:

-un cubo (glutSolidCube)
#include void reshape(int width, int height)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-2,2, -2, 2, 1, 10);
glMatrixMode(GL_MODELVIEW);
} void display(){
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.3,0.3,.9);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -3.0f);
glRotatef(90, 1.0f, 0.0f, 0.0f);
glRotatef(90, 0.0f, 1.0f, 0.0f);
glutSolidCube(1.5);
glFlush();
} void init(){
glClearColor(0,0,0,0);} int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(80, 20);
glutInitWindowSize(250, 250);
glutCreateWindow("Cubo");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop(); return 0; }

-un cono (glutCore)
#include void reshape(int width, int height)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-2,2, -2, 2, 1, 10);
glMatrixMode(GL_MODELVIEW);
} void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.3,0.3,.9);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -3.0f);
glRotatef(220, 1.0f, 0.0f, 0.0f);
glRotatef(0, 0.0f, 1.0f, 0.0f);
glutSolidCone(1,2,50,10);
glFlush();}
void init(){
glClearColor(0,0,0,0);} int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(80, 20);
glutInitWindowSize(250, 250);
glutCreateWindow("Cono");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop(); return 0; }

-un toro (glutTorus)
#include void reshape(int width, int height)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-2,2, -2, 2, 1, 10);
glMatrixMode(GL_MODELVIEW);
} void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.3,0.3,.9);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -3.0f);
glRotatef(220, 1.0f, 0.0f, 0.0f);
glRotatef(0, 0.0f, 1.0f, 0.0f);
glutSolidTorus(0.3,1.5,15,15);
glFlush();
} void init(){
glClearColor(0,0,0,0);
} int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(80, 20);
glutInitWindowSize(250, 250);
glutCreateWindow("Torus");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop(); return 0;
}

3.- A cada uno de estos objetos aplíqueles una composición de transformaciones, insertando el siguiente código:
glRotate (30.0,1.0,0.0,0.0);
glTranslate(0.5,0.5,-0.5);
glScale(2.0,0.5,1.0);


#include

void reshape(int width, int height)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-2,2, -2, 2, 1, 10);
glMatrixMode(GL_MODELVIEW);
}
void display(){
glClear(GL_COLOR_BUFFER_BIT)
glColor3f(0.3,0.3,.9);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -2.5f);
glRotatef(120, 1.0f, 0.0f, 0.0f);
glRotatef(120, 0.0f, 1.0f, 0.0f);
glScalef(2,0.5,1);
glutSolidCube(1.5);
glFlush();
}
void init(){
glClearColor(0,0,0,0);
}
int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(80, 20);
glutInitWindowSize(250, 250);
glutCreateWindow("Cubo");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

#include

void reshape(int width, int height)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-2,2, -2, 2, 1, 10);
glMatrixMode(GL_MODELVIEW);
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.3,0.3,.9);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -3.5f);
glRotatef(210, 1.0f, 0.0f, 0.0f);
glRotatef(210, 0.0f, 1.0f, 0.0f);
glScalef(1,0.5,0.5);
glutSolidCone(2,4,50,10);
glFlush();
}
void init(){
glClearColor(0,0,0,0);
}
int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(80, 20);
glutInitWindowSize(250, 250);
glutCreateWindow("Cono");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;

#include void reshape(int width, int height)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-2,2, -2, 2, 1, 10);
glMatrixMode(GL_MODELVIEW);
} void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.3,0.3,.9);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -4.5f);
glRotatef(120, 1.0f, 0.0f, 0.0f);
glRotatef(120, 0.0f, 1.0f, 0.0f);
glScalef(1,0.5,0.5);
glutSolidTorus(0.3,1.5,20,20);
glFlush();
} void init(){
glClearColor(0,0,0,0);
} int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(80, 20);
glutInitWindowSize(250, 250);
glutCreateWindow("Torus");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop(); return 0;
}