COLEGIO DE ESTUDIOS CIENTIFICOS Y TECNOLOGICOS DEL ESTADO DE MEXICO

LEIDY VIVANI OLVERA LEON

ROSARIO GUTIERREZ URBINA

GRUPO: 303

PROFESOR: RENE DOMINGUEZ ESCALONA

MANUAL DE OPEN GL

INTRODUCCION

OpenGL es una interfaz software de hardware gráfico, es decir de fine las funciones que se pueden utilizar en una aplicación para acceder a las prestaciones de un dispositivo gráfico. Es un motor 3D cuyas rutinas están integradas en tarjetas gráficas 3D. Fue desarrollado por Sillicon Graphics, Inc. (SGI) con el afán de hacer un estándar de representación en 3D. Es compatible con prácticamente cualquier plataforma hardware así como con muchos lenguajes de programación (C,C++, Visual Basic, Visual Fortran, Java)

En este manual aprenderemos a realizar algunas prácticas en el programa Open Gl Dev c++, asi mismo aprenderemos las partes que lo componen y las primitivas que se deben de usar para la realización de distintos dibujos y animaciones en dicho programa.

TABLERO DE AJEDREZ

En esta práctica realizaremos un tablero de ajedrez utilizando las primitivas glBegin(GL_POINTS); esta primitiva nos servirá para realizar los puntos en los que estará situado cada uno de los cuadros, así mismo utilizaremos la primitiva glPointSize(); para ponerle un tamaño especifico a los puntos que se realizarán para los cuadros utilizados en esta actividad.

Recuerda que los tableros de ajedrez tienen 8 cuadros por cada lado del tablero así que tendrás que definir bien las coordenadas para cada uno de los cuadros para que esta actividad salga de la forma en que la quieres.

BORRADOR

CODIGO

//mi primer ventana

#include <GL/glut.h>

#include <GL/gl.h>

#include <GL/glu.h>

void inicializa(void)

{

glClearColor(1.0,.0,5.0,1.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 1050.0, 0.0, 1000.0); //vista ortogonal

}

void dibuja(void) //funcion dibuja

{

glClear(GL_COLOR_BUFFER_BIT); //borra pantalla

glColor3f(0.0 , 0.0 , 0.0);

glPointSize(60);

glBegin(GL_POINTS);

glVertex2i(100,100);

glVertex2i(347,100);

glVertex2i(597,100);

glVertex2i(848,100);

glVertex2i(220,220);

glVertex2i(473,220);

glVertex2i(723,220);

glVertex2i(970,220);

glVertex2i(100,340);

glVertex2i(347,340);

glVertex2i(597,340);

glVertex2i(848,340);

glVertex2i(220,460);

glVertex2i(473,460);

glVertex2i(723,460);

glVertex2i(970,460);

glVertex2i(100,580);

glVertex2i(347,580);

glVertex2i(597,580);

glVertex2i(848,580);

glVertex2i(220,700);

glVertex2i(473,700);

glVertex2i(723,700);

glVertex2i(970,700);

glVertex2i(100,820);

glVertex2i(347,820);

glVertex2i(597,820);

glVertex2i(848,820);

glEnd();

glColor3f(1.0 , 1.0 , 1.0);

glPointSize(60);

glBegin(GL_POINTS);

glVertex2i(220,100);

glVertex2i(473,100);

glVertex2i(723,100);

glVertex2i(970,100);

glVertex2i(100,220);

glVertex2i(347,220);

glVertex2i(597,220);

glVertex2i(848,220);

glVertex2i(220,340);

glVertex2i(473,340);

glVertex2i(723,340);

glVertex2i(970,340);

glVertex2i(100,460);

glVertex2i(347,460);

glVertex2i(597,460);

glVertex2i(848,460);

glVertex2i(220,580);

glVertex2i(473,580);

glVertex2i(723,580);

glVertex2i(970,580);

glVertex2i(100,700);

glVertex2i(347,700);

glVertex2i(597,700);

glVertex2i(848,700);

glVertex2i(220,820);

glVertex2i(473,820);

glVertex2i(723,820);

glVertex2i(970,820);

glEnd();

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(500,500); //tamaño de la ventana

glutInitWindowPosition(0,0); //posicion inicial de la ventana

glutCreateWindow("MI primer ventana"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

CUBO CON LINEAS

En esta actividad realizaremos un cubo con puras líneas para ello ocuparemos la primitiva (GL_LINES) con esta podremos realizar todas las líneas del cubo, así mismo utilizaremos la primitiva, glLineWidth (); con la cual podremos ponerle el tamaño que deseemos a la líneas que conformaran el cubo, con las primitivas anteriores realizaremos el cubo como el que se muestra a continuación:

El código de dicho cubo nos quedara de la siguiente forma:

//mi primer ventana

#include <GL/glut.h>

#include <GL/gl.h>

#include <GL/glu.h>

void inicializa(void)

{

glClearColor(0.0,1.0,1.0,0.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(50.0, 500.0, 50.0, 500.0); //vista ortogonal

}

void dibuja(void) //funcion dibuja

{

glClear(GL_COLOR_BUFFER_BIT);

glLineWidth (10);

glBegin(GL_LINES);

// atras

glColor3f (1.0 , 1.0 , 1.0);

glLineWidth (20);

glVertex2i (100,200);

glVertex2i (300,200);

glVertex2i (300,200);

glVertex2i (300,400);

glVertex2i (300,400);

glVertex2i (100,400);

glVertex2i (100,400);

glVertex2i (100,200);

// frente

glColor3f (1.0, 1.0, 1.0);

glVertex2i (200,100);

glVertex2i (200,300);

glVertex2i (200,300);

glVertex2i (400,300);

glVertex2i (400,300);

glVertex2i (400,100);

glVertex2i (400,100);

glVertex2i (200,100);

glColor3f (1.0, 1.0, 1.0);

glVertex2i (400,100);

glVertex2i (300,200);

glVertex2i (200,100);

glVertex2i (100,200);

glVertex2i (400,300);

glVertex2i (300,400);

glVertex2i (200,300);

glVertex2i (100,400);

glEnd();

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(500,500); //tamaño de la ventana

glutInitWindowPosition(0,0); //posicion inicial de la ventana

glutCreateWindow("MI primer ventana"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

El siguiente paso después de la realización del código es compilarlo para verificar que el código ha sido escrito correctamente y funciona de la forma adecuada como se muestra a continuación:

ESTRELLA

En esta actividad realizaremos una estrella con puras líneas, para ello utilizaremos la primitiva (GL_LINES) para realizar las líneas de dicha estrella, así mismo utilizaremos la primitiva glLineWidth (); la cual nos servirá para colocar el tamaño de la línea en que se quiera tener la estrella; tenemos que tener en cuenta la ubicación de las coordenadas de cada punto para que la estrella salga de la forma en la que esperamos como la que se muestra a continuación:

Se darán cuenta de que es muy sencillo realizar una estrella con este programa lo único que se tiene que hacer es poner atención en las coordenadas que llevara cada punto y e código quedara de la siguiente forma:

//mi primer ventana

#include <GL/glut.h>

#include <GL/gl.h>

#include <GL/glu.h>

void inicializa(void)

{

glClearColor(0.0,1.0,1.0,0.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(50.0, 500.0, 50.0, 500.0); //vista ortogonal

}

void dibuja(void) //funcion dibuja

{

glClear(GL_COLOR_BUFFER_BIT);

glLineWidth (5);

glBegin(GL_LINES);

// atras

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(200,100);

glVertex2i(300,400);

glVertex2i(300,400);

glVertex2i(400,100);

glVertex2i(400,100);

glVertex2i (100,300);

glVertex2i (100,300);

glVertex2i (500,300);

glVertex2i (500,300);

glVertex2i (200,100);

glEnd();

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(500,500); //tamaño de la ventana

glutInitWindowPosition(0,0); //posicion inicial de la ventana

glutCreateWindow("MI primer ventana"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

El siguiente paso después de la realización del código es compilarlo para verificar que el código ha sido escrito correctamente y funciona de la forma adecuada como se muestra a continuación:

PIRAMIDE

En esta actividad realizaremos una pirámide vista desde arriba, para ello utilizaremos la primitiva (GL_LINES) que nos servirá para la realización de las líneas correspondientes a la pirámide, así mismo utilizaremos la primitiva for(i=1;i<=10;i++){ la cual nos servirá para multiplicar las líneas o escalones de la pirámide, también utilizaremos la primitiva glLineWidth (); para el grosor de las líneas de nuestra pirámide; en esta practica tendremos cuidado al colocar las coordenadas que tendrá cada uno de los puntos de nuestra pirámide ya que si no lo hacemos a si no saldrá de la forma en que esperamos como la que se muestra a continuación:

Como se abran dado cuenta esta actividad no es sencilla ya que ha y que colocar distintas coordenadas en cada uno de los puntos de la pirámide para que con la primitiva for podamos multiplicar las líneas o escalones de la pirámide a continuación les presentamos el código para la realización de esta práctica:

//mi primer ventana

#include <GL/glut.h>

#include <GL/gl.h>

#include <GL/glu.h>

void inicializa(void)

{

glClearColor(0.0,0.0,1.0,0.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 1000.0, 0.0, 1000.0); //vista ortogonal

}

void dibuja(void) //funcion dibuja

{

int i,a=25;

glClear(GL_COLOR_BUFFER_BIT); //borra pantalla

glColor3f(1.0 , 0.0 , 0.0);

glLineWidth(5);

glBegin(GL_LINES);

//Valor incial --- Valor final o condicion --- incremento

for(i=1;i<=10;i++){

//Abajo

glVertex2i (240-20*i, 240-20*i);

glVertex2i (260+20*i, 240-20*i);

//Derecha

glVertex2i (260+20*i, 240-20*i);

glVertex2i (260+20*i, 260+20*i);

//Izquierda

glVertex2i (240-20*i, 240-20*i);

glVertex2i (240-20*i, 260+20*i);

//Arriba

glVertex2i (240-20*i, 260+20*i);

glVertex2i (260+20*i, 260+20*i);

//lineas

glVertex2i (450,450);

glVertex2i (300,300);

glVertex2i (200,200);

glVertex2i (50,50);

glVertex2i (450,50);

glVertex2i (300,200);

glVertex2i (50,450);

glVertex2i (200,300);

}

glEnd();

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(500,500); //tamaño de la ventana

glutInitWindowPosition(0,0); //posicion inicial de la ventana

glutCreateWindow("MI primer ventana"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

El siguiente paso después de la realización del código es compilarlo para verificar que el código ha sido escrito correctamente y funciona de la forma adecuada como se muestra a continuación:

CUBO DELINEADO Y RELLENO

En esta actividad realizaremos un cubo relleno y delineado, para ello utilizaremos la primitiva (GL_QUADS) Con la cual podremos realizar cada una de las caras del cubo, con esta primitiva glColor3f (0.0, 0.0, 0.0); podemos ponerle color de fondo a las caras del nuestro cubo, así mismo utilizaremos la primitiva (GL_LINES) ya que con ella podremos darle el delineado a el cubo, también utilizaremos la primitiva glLineWidth (); para el grosor de las líneas como el que se muestra a continuación:

Esta práctica no es muy difícil de hacer ya que utilizamos lo antes visto, lo único nuevo es la primitiva (GL_QUADS) la cual es muy sencilla de utilizar, siempre y cuando las coordenadas que se están dando sean las correctas a continuación les presentamos el código para la realización de esta actividad:

//mi primer ventana

#include <GL/glut.h>

#include <GL/gl.h>

#include <GL/glu.h>

void inicializa(void)

{

glClearColor(1.0,1.0,1.0,1.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 1000.0, 0.0, 1000.0); //vista ortogonal

}

void dibuja(void) //funcion dibuja

{

glClear(GL_COLOR_BUFFER_BIT); //borra pantalla

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_QUADS);

//ATRAS

glColor3f(1.0 , 0.9 , 1.0);

glVertex2d(100,200);

glVertex2d(300,200);

glVertex2d(300,400);

glVertex2d(100,400);

// lado derecho

glColor3f(1.0 , 0.5 , 1.0);

glVertex2d (100,400);

glVertex2d (100,200);

glVertex2d (200,100);

glVertex2d (200,300);

// Arriba

glColor3f (1.0, 0.9, 1.0);

glVertex2d (100,400);

glVertex2d (200,300);

glVertex2d (400,300);

glVertex2d (400,300);

// Abajo

glColor3f (1.0, 0.0, 0.5);

glVertex2d (100,200);

glVertex2d (200,100);

glVertex2d (400,100);

glVertex2d (300,200);

// Lado izquierdo

glColor3f (1.0, 0.0, 0.9);

glVertex2d (400,100);

glVertex2d (400,300);

glVertex2d (300,400);

glVertex2d (300,200);

// Frente

glColor3f (1.5, 1.0, 0.0);

glVertex2d (200,100);

glVertex2d (200,300);

glVertex2d (400,300);

glVertex2d (400,100);

glEnd();

glColor3f (0.0 , 0.0 , 0.0);

glLineWidth (5);

glBegin(GL_LINES);

// atras

glColor3f (0.0 , 0.0 , 0.0);

glLineWidth (20);

glVertex2i (100,200);

glVertex2i (300,200);

glVertex2i (300,200);

glVertex2i (300,400);

glVertex2i (300,400);

glVertex2i (100,400);

glVertex2i (100,400);

glVertex2i (100,200);

// frente

glColor3f (0.0, 0.0, 0.0);

glVertex2i (200,100);

glVertex2i (200,300);

glVertex2i (200,300);

glVertex2i (400,300);

glVertex2i (400,300);

glVertex2i (400,100);

glVertex2i (400,100);

glVertex2i (200,100);

glColor3f (0.0, 0.0, 0.0);

glVertex2i (400,100);

glVertex2i (300,200);

glVertex2i (200,100);

glVertex2i (100,200);

glVertex2i (400,300);

glVertex2i (300,400);

glVertex2i (200,300);

glVertex2i (100,400);

glEnd();

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(500,500); //tamaño de la ventana

glutInitWindowPosition(0,0); //posicion inicial de la ventana

glutCreateWindow("MI primer ventana"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

El siguiente paso después de la realización del código es compilarlo para verificar que el código ha sido escrito correctamente y funciona de la forma adecuada como se muestra a continuación:

MUÑECO CON TRIANGULOS

En esta actividad realizaremos un muñequito hecho con triángulos, para ello utilizaremos la primitiva (GL_TRIANGLES) con la cual realizaremos los triángulos que llevara el muñeco, así mismo utilizaremos la primitiva (GL_QUADS) para el cuerpo del muñeco, también ocuparemos la primitiva (GL_POLYGON) que nos servirá para la realización del trofeo y del balón. A continuación les presentamos un borrador de las coordenadas que podrán utilizar para realizar esta práctica:

Esta actividad esta un poco complicada ya que estamos utilizando nuevas primitivas con las cuales no habíamos trabajado antes, pero que no son muy difíciles de realizarlas solo tienes que prestar atención a las coordenadas que estas estableciendo para que todo te salga bien A continuación les presentamos el código para la realización de esta práctica:

//mi primer dibujo

#include <GL/glut.h>

#include <GL/gl.h>

#include <GL/glu.h>

void inicializa(void)

{

glClearColor(1.0,0.0,1.0,0.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 2000.0, 0.0, 2000.0); //vista ortogonal

}

void dibuja(void) //funcion dibuja

{

glClear(GL_COLOR_BUFFER_BIT); //borra pantalla

glBegin(GL_TRIANGLES);

glColor3f (0.0, 0.0, 0.0);

//gorro

glVertex2f (440,760);

glVertex2f (600,880);

glVertex2f (760,760);

glEnd();

//cabeza

glColor3f (1.0, 0.0, 0.0);

glBegin(GL_TRIANGLES);

glVertex2f (520,760);

glVertex2f (600,640);

glVertex2f (680,760);

glEnd();

//corbata

glColor3f (0.0, 0.0, 0.0);

glBegin(GL_TRIANGLES);

glVertex2f (560,640);

glVertex2f (600,600);

glVertex2f (640,640);

glEnd();

//cuerpazo

glBegin(GL_QUADS);

glVertex2f (480,640);

glVertex2f (480,360);

glVertex2f (720,360);

glVertex2f (720,640);

glEnd();

//brazo izquierdp

glColor3f (1.0 , 1.5 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2f (480,640);

glVertex2f (360,360);

glVertex2f (280,440);

glEnd();

//brazo derecho

glColor3f (1.0, 1.5, 0.0);

glBegin(GL_TRIANGLES);

glVertex2f (720,640);

glVertex2f (920,400);

glVertex2f (840,360);

glEnd();

//mano izquierda

glColor3f (1.0, 1.5, 0.0);

glBegin(GL_TRIANGLES);

glVertex2f (240,520);

glVertex2f (280,440);

glVertex2f (240,400);

glEnd();

//mano derecha

glColor3f (1.0, 1.5, 0.0);

glBegin(GL_TRIANGLES);

glVertex2f(960,520);

glVertex2f (960,400);

glVertex2f (920,400);

//pata derecha

glColor3f (0.0, 0.0, 0.0);

glBegin(GL_TRIANGLES);

glVertex2f (640,360);

glVertex2f (800,280);

glVertex2f (640,280);

glEnd();

//abajo pata

glColor3f (1.0, 1.5, 0.0);

glBegin(GL_TRIANGLES);

glVertex2f (800,120);

glVertex2f (720,200);

glVertex2f (800,280);

glEnd();

//pata abjao abajo

glColor3f (1.0, 1.5, 0.0);

glBegin(GL_TRIANGLES);

glVertex2f (800,120);

glVertex2f (880,160);

glVertex2f (960,120);

glEnd();

//pata abajo izquierda

glColor3f (1.0, 1.5, 0.0);

glBegin(GL_TRIANGLES);

glVertex2f (400, 40);

glVertex2f (480, 80);

glVertex2f (560, 40);

glEnd();

glColor3f (1.0, 00, 0.0);

glBegin(GL_POLYGON);

glVertex2f (840,120);

glVertex2f (880,120);

glVertex2f (920,80);

glVertex2f (920,40);

glVertex2f (880,0);

glVertex2f (840,0);

glVertex2f (800,40);

glVertex2f (800,80);

glEnd();

//trofeo

glColor3f (1.0, 00, 0.5);

glBegin(GL_POLYGON);

glVertex2f (920,600);

glVertex2f (1000,600);

glVertex2f (960,560);

glVertex2f (1040,440);

glVertex2f (1040,360);

glVertex2f (1000,400);

glVertex2f (920,560);

glEnd();

glColor3f (1.0, 1.5, 0.0);

glBegin(GL_TRIANGLES);

glVertex2f (1000, 600);

glVertex2f (1120, 600);

glColor3f (1.0, 0.0, 0.0);

glVertex2f (1060, 360);

glEnd();

glColor3f (1.0, 00, 0.5);

glBegin(GL_POLYGON);

glVertex2f (1080, 360);

glVertex2f (1080, 440);

glVertex2f (1160, 560);

glVertex2f (1160, 560);

glVertex2f (1120, 600);

glVertex2f (1200, 600);

glVertex2f (1200, 560);

glEnd();

glColor3f (1.0, 1.5, 0.0);

glBegin(GL_TRIANGLES);

glVertex2f (560,360);

glVertex2f (560,40);

glVertex2f (480,280);

glEnd();

glColor3f (1.0, 00, 0.5);

glBegin(GL_TRIANGLES);

glVertex2f (1000, 320);

glVertex2f (1060, 360);

glVertex2f (1120, 320);

glEnd();

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(500,500); //tamaño de la ventana

glutInitWindowPosition(0,0); //posicion inicial de la ventana

glutCreateWindow("mi primera ventana"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

El siguiente paso después de la realización del código es compilarlo para verificar que el código ha sido escrito correctamente y funciona de la forma adecuada como se muestra a continuación:

CASITA

En esta práctica se ocuparan los cuadrados, triángulos, polígonos, líneas y si es necesario círculos y degradados, para crear una casa.

Código:

#include <GL/glut.h>

#include <GL/gl.h>

#include <math.h>

void inicializa(void)

{

glClearColor(0.0,1.0,1.0,0.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 2000.0, 0.0, 2000.0); //vista ortogonal

}

void circuloc(int x, int y, int t, int radio)

{

int angulo=0;

glPointSize(t);

glBegin(GL_POINTS);

//glColor3f (1.0, 0.0, 1.0);

glVertex2f(x,y);

//glColor3f(0,0.0,0.0);

for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void circulo(int x, int y, int radio)

{

int angulo=0;

glBegin(GL_TRIANGLE_FAN);

// glColor3f (1.0, 0.0, 1.0);

glVertex2f(x,y);

for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void dibuja(void) //funcion dibuja

{

glClear(GL_COLOR_BUFFER_BIT);

glColor3f(1.0,0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(0,680);

glVertex2f(0,640);

glVertex2f(1640,640);

glVertex2f(1640,680);

glEnd();

//techo

glColor3f(1.0 , 00, 0.0);

glBegin(GL_POLYGON);

glVertex2f(920,1200);

glVertex2f(840,1280);

glVertex2f(400,1280);

glVertex2f(320,1200);

glEnd();

//cuerpo de casa

glColor3f(0.0 , 0.0, 0.0);

glBegin(GL_QUADS);

glVertex2f(360,1200);

glVertex2f(880,1200);

glVertex2f(880,600);

glVertex2f(360,600);

glEnd();

//ventana izquierda

glColor3f(1.0 , 1.0, 1.0);

glBegin(GL_QUADS);

glVertex2f(360,1120);

glVertex2f(360,1000);

glVertex2f(480,1000);

glVertex2f(480,1120);

glEnd();

//ventana derecha

glColor3f(1.0 , 1.0, 1.0);

glBegin(GL_QUADS);

glVertex2f(760,1120);

glVertex2f(760,1000);

glVertex2f(880,1000);

glVertex2f(880,1120);

glEnd();

//linea cuerpo izquierda

glColor3f(0.0 , 1.0, 0.0);

glBegin(GL_QUADS);

glVertex2f(480,1160);

glVertex2f(480,600);

glVertex2f(520,600);

glVertex2f(520,1160);

glEnd();

glColor3f(0.0 , 1.0, 0.0);

glBegin(GL_QUADS);

glVertex2f(720,1160);

glVertex2f(720,600);

glVertex2f(760,600);

glVertex2f(760,1160);

glEnd();

//triangulo ttecho

glColor3f(1.0 , 1.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2f(480,1160);

glVertex2f(600,1240);

glVertex2f(760,1160);

glEnd();

//cuadro abajo de triangulo techo

glColor3f(1.0, 0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(520,1160);

glVertex2f(520,1000);

glColor3f(0.0 , 0.0,1.0);

glVertex2f(720,1000);

glColor3f(0.0 , 0.0,0.0);

glVertex2f(720,1160);

glEnd();

glColor3f(0.0, 1.0,0.0);

glBegin(GL_QUADS);

glVertex2f(600,1160);

glVertex2f(600,1000);

glVertex2f(640,1000);

glVertex2f(640,1160);

glEnd();

//vcentanales

glColor3f(1.0,1.0,0.0);

glBegin(GL_QUADS);

glVertex2f(520,1000);

glVertex2f(520,920);

glVertex2f(560,920);

glVertex2f(560,1000);

glEnd();

glColor3f(1.0,1.0,1.0);

glBegin(GL_QUADS);

glVertex2f(560,1000);

glVertex2f(560,920);

glVertex2f(600,920);

glVertex2f(600,1000);

glEnd();

glColor3f(1.0,1.0,0.0);

glBegin(GL_QUADS);

glVertex2f(600,1000);

glVertex2f(600,920);

glVertex2f(640,920);

glVertex2f(640,1000);

glEnd();

glColor3f(1.0,1.0,1.0);

glBegin(GL_QUADS);

glVertex2f(640,1000);

glVertex2f(640,920);

glVertex2f(680,920);

glVertex2f(680,1000);

glEnd();

glColor3f(1.0,1.0,0.0);

glBegin(GL_QUADS);

glVertex2f(680,1000);

glVertex2f(680,920);

glVertex2f(720,920);

glVertex2f(720,1000);

glEnd();

//linea horizontal cuerpo casa

glColor3f(0.0,1.0,0.0);

glBegin(GL_QUADS);

glVertex2f(360,920);

glVertex2f(360,880);

glVertex2f(880,880);

glVertex2f(880,920);

glEnd();

//ventana izquierda abajao

glColor3f(1.0,1.0,1.0);

glBegin(GL_QUADS);

glVertex2f(360,800);

glVertex2f(360,680);

glVertex2f(480,680);

glVertex2f(480,800);

glEnd();

//ventana derecha abajo

glColor3f(1.0,1.0,1.0);

glBegin(GL_QUADS);

glVertex2f(760,800);

glVertex2f(760,680);

glVertex2f(880,680);

glVertex2f(880,800);

glEnd();

//puerta

glColor3f(1.0,0.0,1.0);

glBegin(GL_QUADS);

glVertex2f(520,840);

glVertex2f(520,600);

glVertex2f(720,600);

glVertex2f(720,840);

glEnd();

//dentro de puerta

glColor3f(1.0,0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(560,800);

glVertex2f(560,640);

glVertex2f(640,640);

glVertex2f(640,800);

glEnd();

//manija

glColor3f(0.0,0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(640,720);

glVertex2f(640,680);

glVertex2f(680,680);

glVertex2f(680,720);

glEnd();

//cochera

glColor3f(1.0 , 00, 0.0);

glBegin(GL_POLYGON);

glVertex2f(360,880);

glVertex2f(80,880);

glVertex2f(40,800);

glVertex2f(360,800);

glEnd();

glColor3f(1.0 , 00, 0.0);

glBegin(GL_QUADS);

glVertex2f(0,320);

glVertex2f(0,280);

glColor3f(1.0 , 1.0,0.0);

glVertex2f(1680,280);

glColor3f(1.0 , 1.0,0.0);

glVertex2f(1680,320);

glEnd();

glColor3f(1.0 , 00, 0.0);

glBegin(GL_QUADS);

glVertex2f(520,320);

glVertex2f(520,600);

glColor3f(1.0 , 1.0,0.0);

glVertex2f(720,600);

glColor3f(1.0 , 1.0,0.0);

glVertex2f(720,320);

glEnd();//cuerpo cochera

glColor3f(1.0,0.0,1.0);

glBegin(GL_POLYGON);

glVertex2f(80,800);

glVertex2f(80,600);

glVertex2f(360,600);

glVertex2f(360,800);

glEnd();

glColor3f(1.0 , 1.0,0.0);

glBegin(GL_QUADS);

glVertex2f(0,280);

glVertex2f(0,240);

glVertex2f(1680,240);

glVertex2f(1680,280);

glEnd();

//carretera

glColor3f(0.0 , 0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(0,240);

glVertex2f(0,0);

glVertex2f(1680,0);

glVertex2f(1680,240);

glEnd();

//barras de carretyera

glColor3f(1.0 , 1.0,1.0);

glBegin(GL_QUADS);

glVertex2f(40,160);

glVertex2f(40,120);

glVertex2f(440,120);

glVertex2f(440,160);

glEnd();

glColor3f(1.0 , 1.0,1.0);

glBegin(GL_QUADS);

glVertex2f(520,160);

glVertex2f(520,120);

glVertex2f(920,120);

glVertex2f(920,160);

glEnd();

glColor3f(1.0 , 1.0,1.0);

glBegin(GL_QUADS);

glVertex2f(1080,160);

glVertex2f(1080,120);

glVertex2f(1560,120);

glVertex2f(1560,160);

glEnd();

//pasto

glColor3f(0.0 , 1.0,0.0);

glBegin(GL_QUADS);

glVertex2f(0,600);

glVertex2f(0,320);

glVertex2f(520,320);

glVertex2f(520,600);

glEnd();

glColor3f(0.0 , 1.0,0.0);

glBegin(GL_QUADS);

glVertex2f(720,600);

glVertex2f(720,320);

glVertex2f(1680,320);

glVertex2f(1680,600);

glEnd();

//carro izquierda

glColor3f(1.0,0.0,0.0);

glBegin(GL_POLYGON);

glVertex2f(400,440);

glVertex2f(240,440);

glVertex2f(160,360);

glVertex2f(480,360);

glEnd();

glColor3f(1.0 , 0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(160,360);

glVertex2f(160,280);

glVertex2f(600,280);

glVertex2f(600,360);

glEnd();

//ventanas carro izquierdo

glColor3f(0.0 , 0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(200,400);

glVertex2f(200,320);

glVertex2f(280,320);

glVertex2f(280,400);

glEnd();

glColor3f(0.0 , 0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(320,400);

glVertex2f(320,320);

glVertex2f(400,320);

glVertex2f(400,400);

glEnd();

//trailer

glColor3f(1.0,0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(920,360);

glVertex2f(920,240);

glVertex2f(1160,240);

glVertex2f(1160,360);

glEnd();

glColor3f(1.0 , 1.0 , 1.0);

glBegin(GL_TRIANGLES);

glVertex2f(960,360);

glVertex2f(1000,440);

glVertex2f(1000,360);

glEnd();

glColor3f(1.0,0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(1000,440);

glVertex2f(1000,360);

glVertex2f(1160,360);

glVertex2f(1160,440);

glEnd();

//ventana trailer cuadrada

glColor3f(1.0,1.0,1.0);

glBegin(GL_QUADS);

glVertex2f(1040,440);

glVertex2f(1040,360);

glVertex2f(1120,360);

glVertex2f(1120,440);

glEnd();

//base de treaileer

glColor3f(1.0,0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(880,240);

glVertex2f(880,160);

glVertex2f(1440,160);

glVertex2f(1440,240);

glEnd();

//caja de trailer

glColor3f(1.0,0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(1200,520);

glVertex2f(1200,240);

glVertex2f(1440,240);

glVertex2f(1440,520);

glEnd();

//cosa que le sale al trailer

glColor3f(1.0,0.0,1.0);

glBegin(GL_QUADS);

glVertex2f(840,320);

glVertex2f(840,160);

glVertex2f(880,160);

glVertex2f(880,320);

glEnd();

//a estoes parte de las ventanas de la casa

glColor3f(1.0,0.0,1.0);

glBegin(GL_QUADS);

glVertex2f(360,1080);

glVertex2f(360,1040);

glVertex2f(480,1040);

glVertex2f(480,1080);

glEnd();

glColor3f(1.0,0.0,1.0);

glBegin(GL_QUADS);

glVertex2f(360,760);

glVertex2f(360,720);

glVertex2f(480,720);

glVertex2f(480,760);

glEnd();

glColor3f(1.0,0.0,1.0);

glBegin(GL_QUADS);

glVertex2f(760,1080);

glVertex2f(760,1040);

glVertex2f(880,1040);

glVertex2f(880,1080);

glEnd();

glColor3f(1.0,0.0,1.0);

glBegin(GL_QUADS);

glVertex2f(760,760);

glVertex2f(760,720);

glVertex2f(880,720);

glVertex2f(880,760);

glEnd();

//barandal

glColor3f(1.0,0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(0,720);

glVertex2f(0,600);

glVertex2f(40,600);

glVertex2f(40,720);

glEnd();

glColor3f(1.0,0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(920,720);

glVertex2f(920,600);

glVertex2f(960,600);

glVertex2f(960,720);

glEnd();

glColor3f(1.0,0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(1000,720);

glVertex2f(1000,600);

glVertex2f(1040,600);

glVertex2f(1040,720);

glEnd();

glColor3f(0.6,0.4,0.2);

glBegin(GL_QUADS);

glVertex2f(1080,720);

glVertex2f(1080,600);

glVertex2f(1240,600);

glVertex2f(1240,720);

glEnd();

//tronco

glColor3f(0.6,0.4,0.2);

glBegin(GL_QUADS);

glVertex2f(1120,720);

glVertex2f(1120,600);

glVertex2f(1160,600);

glVertex2f(1160,720);

glEnd();

//ramas

glBegin(GL_LINES);

//llantas

glColor3f(0.6,0.4,0.2);

circulo(240,240,50);

circulo(240,240,25);

glEnd();

glColor3f(0.6,0.4,0.2);

circulo(520,240,50);

circulo(520,240,25);

glEnd();

glColor3f(0.6,0.4,0.2);

circulo(1000,80,100);

circulo(1000,80,50);

glEnd();

glColor3f(0.6,0.4,0.2);

circulo(1360,80,100);

circulo(1360,80,50);

glColor3f(0.0,0.6,0.2);

glBegin(GL_QUADS);

glVertex2f(1000,760);

glVertex2f(1000,720);

glVertex2f(1400,720);

glVertex2f(1400,760);

glEnd();

glColor3f(0.0,0.6,0.2);

glBegin(GL_QUADS);

glVertex2f(1040,840);

glVertex2f(1040,800);

glVertex2f(1320,800);

glVertex2f(1320,840);

glEnd();

glColor3f(0.0,0.6,0.2);

glBegin(GL_QUADS);

glVertex2f(1080,920);

glVertex2f(1080,880);

glVertex2f(1280,880);

glVertex2f(1280,920);

glEnd();

glColor3f(0.0,0.6,0.2);

glBegin(GL_QUADS);

glVertex2f(1120,1000);

glVertex2f(1120,960);

glVertex2f(1240,960);

glVertex2f(1240,1000);

glEnd();

glColor3f(0.0,0.6,0.2);

glBegin(GL_QUADS);

glVertex2f(1160,1080);

glVertex2f(1150,1040);

glVertex2f(1200,1040);

glVertex2f(1200,1080);

glEnd();

//barandal, despues del tronco

glColor3f(1.0,0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(1280,720);

glVertex2f(1280,600);

glVertex2f(1320,600);

glVertex2f(1320,720);

glEnd();

glColor3f(1.0,0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(1360,720);

glVertex2f(1360,600);

glVertex2f(1400,600);

glVertex2f(1400,720);

glEnd();

glColor3f(1.0,0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(1440,720);

glVertex2f(1440,600);

glVertex2f(1480,600);

glVertex2f(1480,720);

glEnd();

glColor3f(1.0,0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(1520,720);

glVertex2f(1520,600);

glVertex2f(1560,600);

glVertex2f(1560,720);

glEnd();

glColor3f(1.0,0.0,0.0);

glBegin(GL_QUADS);

glVertex2f(1600,720);

glVertex2f(1600,600);

glVertex2f(1640,600);

glVertex2f(1640,720);

glEnd();

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(500,500); //tamaño de la ventana

glutInitWindowPosition(0,0); //posicion inicial de la ventana

glutCreateWindow("tablero"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

OSO

Primera práctica en la cual oficialmente se ocuparan los círculos para crear con solo círculos un oso.

Código:

#include <GL/glut.h>

#include <GL/gl.h>

#include <math.h>

void inicializa(void)

{

glClearColor(0.0,1.0,1.0,0.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 2000.0, 0.0, 2000.0); //vista ortogonal

}

void circuloc(int x, int y, int t, int radio)

{

int angulo=0;

glPointSize(t);

glBegin(GL_POINTS);

//glColor3f (1.0, 0.0, 1.0);

glVertex2f(x,y);

//glColor3f(0,0.0,0.0);

for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void circulo(int x, int y, int radio)

{

int angulo=0;

glBegin(GL_TRIANGLE_FAN);

// glColor3f (1.0, 0.0, 1.0);

glVertex2f(x,y);

for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void dibuja(void) //funcion dibuja

{

//cara y orejas

glClear(GL_COLOR_BUFFER_BIT);

glColor3f(0.6 , 0.4, 0.2);

circulo(400,1000,120);

circulo(800,1000,120);

circulo(600,840,200);

glEnd();

//cuerpo

glColor3f(0.6 , 0.4, 0.2);

glBegin(GL_QUADS);

glVertex2f(520,640);

glVertex2f(520,360);

glVertex2f(680,360);

glVertex2f(680,640);

glEnd();

//brazos

glColor3f(0.6 , 0.4, 0.2);

glBegin(GL_QUADS);

glVertex2f(360,640);

glVertex2f(360,560);

glVertex2f(520,560);

glVertex2f(520,640);

glEnd();

glColor3f(0.6 , 0.4, 0.2);

glBegin(GL_QUADS);

glVertex2f(680,640);

glVertex2f(680,560);

glVertex2f(840,560);

glVertex2f(840,640);

glEnd();

//piernas

glColor3f(0.6 , 0.4, 0.2);

glBegin(GL_QUADS);

glVertex2f(440,360);

glVertex2f(440,280);

glVertex2f(520,280);

glVertex2f(520,360);

glEnd();

glColor3f(0.6 , 0.4, 0.2);

glBegin(GL_QUADS);

glVertex2f(680,360);

glVertex2f(680,280);

glVertex2f(760,280);

glVertex2f(760,360);

glEnd();

//patas

glColor3f(0.6 , 0.4, 0.2);

circulo(360,320,120);

circulo(840,320,120);

glEnd();

//manos

glColor3f(0.6 , 0.4, 0.2);

circulo(320,600,120);

circulo(880,600,120);

glEnd();

//ojos

glColor3f(0.0 , 0.0, 0.0);

circulo(520,920,40);

circulo(680,920,40);

glEnd();

//ocico

glColor3f(1.0 , 1.0, 1.0);

circulo(600,800,80);

glEnd();

glColor3f(0.0 , 0.0, 0.0);

circulo(600,800,40);

glEnd();

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(500,500); //tamaño de la ventana

glutInitWindowPosition(0,0); //posicion inicial de la ventana

glutCreateWindow("tablero"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

CUBO CON CUBITOS

Se realizara un cubo hecho de cubos más pequeños y delineados, hasta crear una práctica parecida a la de cubo con líneas, sustituyendo estas por cubos.

Código:

#include <GL/glut.h>

#include <GL/gl.h>

void inicializa(void)

{

glClearColor(1.0,1.0,1.0,0.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 800.0, 0.0, 800.0); //vista ortogonal

}

void cubo (int x, int y,int t,int l){

double a=.8,b=.6;

glColor3f(1.0 , 1.0 , 0.0);

glBegin(GL_QUADS);

glVertex2f(x,y);

glVertex2f(x+t,y);

glVertex2f(x+t,y+t);

glVertex2f(x,y+t);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2f(x,y+t);

glVertex2f(x+t,y+t);

glVertex2f(x+t+(t*a),y+t+(t*b));

glVertex2f(x+(t*a),y+t+(t*b));

glColor3f(1.0 , 0.0 , 0.0);

glVertex2f(x+t,y+t);

glVertex2f(x+t+(t*a),y+t+(t*b));

glVertex2f(x+t+(t*a),y+(t*b));

glVertex2f(x+t,y);

glEnd();

glColor3f(0.0 , 0.0 , 0.0);

glLineWidth(l);

glBegin(GL_LINES);

glVertex2f(x,y);

glVertex2f(x+t,y);

glVertex2f(x+t,y);

glVertex2f(x+t,y+t);

glVertex2f(x+t,y+t);

glVertex2f(x,y+t);

glVertex2f(x,y);

glVertex2f(x,y+t);

glVertex2f(x+t,y+t);

glVertex2f(x+t,y+t);

glVertex2f(x+t+(t*a),y+t+(t*b));

glVertex2f(x+t+(t*a),y+t+(t*b));

glVertex2f(x+(t*a),y+t+(t*b));

glVertex2f(x,y+t);

glVertex2f(x+t+(t*a),y+t+(t*b));

glVertex2f(x+(t*a),y+t+(t*b));

glVertex2f(x+t,y+t);

glVertex2f(x+t+(t*a),y+t+(t*b));

glVertex2f(x+t+(t*a),y+t+(t*b));

glVertex2f(x+t+(t*a),y+(t*b));

glVertex2f(x+t+(t*a),y+(t*b));

glVertex2f(x+t,y);

glVertex2f(x+t,y+t);

glEnd();

}

void dibuja(void) //funcion dibuja

{

glClear(GL_COLOR_BUFFER_BIT); //borra pantalla

glColor3f(1.0 , 0.0 , 0.0);

for(int k=0;k<=7;k++){

cubo(240-20*k*.8,200-20*k*.6,20,5);

}

for(int j=0;j<=12;j++){

cubo(260+20*j,220,20,5);

}

for(int i=0;i<=9;i++){

cubo(260,240+20*i,20,5);

}

for(int k=0;k<=9;k++){

cubo(260-20*k*.8,420-20*k*.6,20,5);

}

for(int j=0;j<=10;j++){

cubo(280+20*j,420,20,5);

}

for(int k=0;k<=9;k++){

cubo(500-20*k*.8,220-20*k*.6,20,5);

}

for(int i=0;i<=8;i++){

cubo(500,240+20*i,20,5);

}

for(int k=0;k<=10;k++){

cubo(500-20*k*.8,420-20*k*.6,20,5);

}

for(int i=0;i<=10;i++){

cubo(100,100+20*i,20,5);

}

for(int j=0;j<=10;j++){

cubo(120+20*j,100,20,5);

cubo(120+20*j,300,20,5);

}

for(int i=0;i<=10;i++){

cubo(340,100+20*i,20,5);

}

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(500,500); //tamaño de la ventana

glutInitWindowPosition(100,100); //posicion inicial de la ventana

glutCreateWindow("Ventana"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

MUÑECO CON FORMAS

En esta práctica realizaremos un muñeco con los conocimientos vistos antes, para ello utilizaremos triángulos, polígonos, círculos, rectángulos, cuadrados y líneas.

Codigo:

//mi primer ventana

#include <GL/glut.h>

#include <GL/gl.h>

#include <GL/glu.h>

#include <math.h>

void inicializa(void)

{

glClearColor(0.0,1.0,1.0,0.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 2000.0, 0.0, 2000.0); //vista ortogonal

}

void circuloc(int x, int y, int t, int radio)

{

int angulo=0;

glPointSize(t);

glBegin(GL_POINTS);

//glColor3f (1.0, 0.0, 1.0);

glVertex2f(x,y);

//glColor3f(0,0.0,0.0);

for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void circulo(int x, int y, int radio)

{

int angulo=0;

glBegin(GL_TRIANGLE_FAN);

// glColor3f (1.0, 0.0, 1.0);

glVertex2f(x,y);

for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void dibuja(void) //funcion dibuja

{

glClear(GL_COLOR_BUFFER_BIT);

glColor3f(1.0 , 00, 0.0);

// cabeza

glColor3f(0.8,0.7,0.6); //borra pantalla

circulo(1000,1000,200);

// ojos

glColor3f(0.0,0.0,0.0);

circulo(950,1050,10);

circulo(1100,1050,10);

glEnd();

//orejas

glColor3f(0.8,0.7,0.6);

circulo(800,1000,50);

circulo(1200,1000,50);

glEnd();

//cuello

glBegin(GL_POLYGON);

glColor3f(0.8,0.7,0.6);

glVertex2f(1050,750);

glVertex2f(1050,820);

glVertex2f(950,820);

glVertex2f(950,750);

glVertex2f(1000,650);

// Playera

glBegin(GL_POLYGON);

glColor3f(1.0,0.0,0.0);

glVertex2f(1200,350);

glVertex2f(1200,550);

glVertex2f(1250,450);

glVertex2f(1350,450);

glVertex2f(1200,750);

glVertex2f(1050,750);

glVertex2f(1000,650);

glVertex2f(950,750);

glVertex2f(800,750);

glVertex2f(705,450);

glVertex2f(800,450);

glVertex2f(850,550);

glVertex2f(850,350);

glEnd();

//CUERPO

glBegin(GL_TRIANGLES);

glColor3f(1.0,0.0,0.0);

glVertex2f(1200,350);

glVertex2f(1000,650);

glVertex2f(850,350);

glEnd();

glBegin(GL_QUADS);

glColor3f(0.3,0.17,0.16);

glVertex2f(950,650);

glVertex2f(1050,650);

glVertex2f(1050,550);

glVertex2f(950,550);

glVertex2f(950,500);

glVertex2f(1050,500);

glVertex2f(1050,400);

glVertex2f(950,400);

glVertex2f(1200,350);

glVertex2f(850,350);

glVertex2f(850,300);

glVertex2f(1200,300);

glColor3f(0.0,0.0,0.0);

glVertex2f(950,350);

glVertex2f(1050,350);

glVertex2f(1050,300);

glVertex2f(950,300);

// BRAZOS

glColor3f(0.8,0.5,0.4);

glVertex2f(750,450);

glVertex2f(780,450);

glVertex2f(780,380);

glVertex2f(750,380);

glVertex2f(1275,450);

glVertex2f(1305,450);

glVertex2f(1305,380);

glVertex2f(1275,380);

glEnd();

//MANOS IZQUIERDA

glLineWidth (3);

glBegin(GL_LINES);

glColor3f(0.8,0.5,0.4);

glVertex2i(750,380);

glVertex2i(720,350);

glVertex2i(720,350);

glVertex2i(740,360);

glVertex2i(740,360);

glVertex2i(740,320);

glVertex2i(740,320);

glVertex2i(750,360);

glVertex2i(750,360);

glVertex2i(760,320);

glVertex2i(760,320);

glVertex2i(770,360);

glVertex2i(770,360);

glVertex2i(780,320);

glVertex2i(780,320);

glVertex2i(790,360);

glVertex2i(790,360);

glVertex2i(810,350);

glVertex2i(810,350);

glVertex2f(780,380);

// MANO DERECHA

glVertex2f(1275,380);

glVertex2f(1255,350);

glVertex2f(1255,350);

glVertex2f(1270,360);

glVertex2f(1270,360);

glVertex2f(1270,320);

glVertex2f(1270,320);

glVertex2f(1280,360);

glVertex2f(1280,360);

glVertex2f(1290,320);

glVertex2f(1290,320);

glVertex2f(1300,360);

glVertex2f(1300,360);

glVertex2f(1310,320);

glVertex2f(1310,320);

glVertex2f(1320,360);

glVertex2f(1320,360);

glVertex2f(1340,350);

glVertex2f(1340,350);

glVertex2f(1305,380);

// NARIZ

glColor3f(0.0,0.0,0.0);

glVertex2f(1020,1020);

glVertex2f(1000,1000);

glVertex2f(1000,1000);

glVertex2f(1040,1000);

// BOCA

glVertex2f(975,900);

glVertex2f(975,880);

glVertex2f(975,880);

glVertex2f(1050,880);

glVertex2f(1050,880);

glVertex2f(1050,900);

glEnd();

// CABELLO

glBegin(GL_TRIANGLES);

glColor3f(0.0 , 0.0 , 0.0);

glVertex2f(950,1190);

glVertex2f(1100,1250);

glVertex2f(1050,1190);

glEnd();

// PANTALON

glBegin(GL_POLYGON);

glColor3f(0.1,0.4,0.7);

glVertex2f(850,300);

glVertex2f(750,100);

glVertex2f(900,50);

glVertex2f(1020,250);

glVertex2f(1020,300);

glEnd();

glBegin(GL_POLYGON);

glColor3f(0.1,0.4,0.7);

glVertex2f(1020,300);

glVertex2f(1020,250);

glVertex2f(1100,50);

glVertex2f(1250,100);

glVertex2f(1200,300);

glEnd();

glBegin(GL_TRIANGLES);

glColor3f(0.0 , 0.0 , 0.0);

glVertex2f(750,100);

glVertex2f(900,50);

glVertex2f(650,50);

glVertex2f(1100,50);

glVertex2f(1250,100);

glVertex2f(1350,50);

glEnd();

glFlush(); //forza dibujo

}

//funcion dibuja

//forza dibujo

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(900,900); //tamaño de la ventana

glutInitWindowPosition(0,0); //posicion inicial de la ventana

glutCreateWindow("tablero"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

ANIMACIÓN CÍRCULO

Al hacer un círculo, se le pondrá movimiento, para que cubra su recorrido las orillas de la pantalla.

Código:

#include <unistd.h>

#include <GL/glut.h>

#include <GL/gl.h>

#include <math.h>

int x=1, y=1,z=1,w=1;

void inicializa(void){

glClearColor(0.0,0.0,1.0,0.0);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluOrtho2D(0.0, 700.0, 0.0, 700.0);// el ancho y largo de nuestra pantalla

}

void circulo(int x, int y, int radio){

int angulo=0;

glBegin(GL_TRIANGLE_FAN); glColor3f (0.5, 0.5, 0.5);

glVertex2f(x,y);

glColor3f(0,0.0,0.0);

for (angulo=0;angulo<=360; angulo+=6){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();}

void dibuja(void)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

//abajo

if(x>=1 && x<500){circulo(100+1*x,100,40);x++;}

// derecha para arriba

if (x==500 && y>=1 && y<500 ) {circulo(600,100+1*y,40);y++;}

//arriba para izquierda

if (x==500 && y==500 && z>=1 && z<500) {circulo (600-z,600,40);z++;}

//izquerda hacia abajo

if (x==500 && y==500 && z==500 && w>=1 && w<500){circulo (100,600-w,40);w++;}

if(w==500){ x=1;y=1; z=1; w=1;}

glFlush();

glutSwapBuffers();

}

int main (int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA| GLUT_DEPTH);

glutInitWindowSize(700,700);

glutInitWindowPosition(10,10);

glutCreateWindow("Ventana");

inicializa();

glutDisplayFunc(dibuja);

glutIdleFunc(dibuja);

glutMainLoop();

return 0;

}

ANIMACIÓN SISTEMA SOLAR.

Movimiento circular, será lo que tendrán nuestros planetas (círculos). Se realizaran las “orbitas” y sobre su circunferencia de estas, giraran.

Código:

#include <unistd.h>

#include <GL/glut.h>

#include <GL/gl.h>

#include <math.h>

int rad=100;

double ang=0,a=0,b=0,c=0, d=0, e=0, f=0;

void inicializa(void)

{

glClearColor(0.0,0.0,0.0,0.0);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluOrtho2D(0.0, 1000.0, 0.0, 1000.0);// el ancho y largo de nuestra pantalla

}

void circulo(int x, int y, int radio)

{

int angulo=0;

glBegin(GL_TRIANGLE_FAN);

glVertex2f(x,y);

for (angulo=0;angulo<=360; angulo++){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void circuloc(int x, int y, int t, int radio)

{

int angulo=0;

glPointSize(t);

glBegin(GL_POINTS);

glVertex2f(x,y);

for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void dibuja(void)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto

glColor3f(1.0,0.0,0.0);

circulo( 500+ sin(ang) * 0,500 + cos(ang) * 0,50); //funcion circulo

glColor3f(1.0,1.0,1.0);

circuloc(500,500,1,100);

circuloc(500,500,1,150);

circuloc(500,500,1,200);

circuloc(500,500,1,250);

circuloc(500,500,1,300);

circuloc(500,500,1,350);

circuloc(500,500,1,400);

circuloc(500,500,1,450);

glColor3f(0.8,0.4,0.1);

circulo( 500+ sin(a) * 100,500 + cos(a) * 100,5);

glColor3f(0.6,0.3,0.1);

circulo( 500+ sin(b) * 150,500 - cos(b) * 150,7);

glColor3f(0.1,0.7,0.8);

circulo( 500+ sin(c) * 200,500 + cos(c) * 200,10);

glColor3f(0.8,0.07,0.2);

circulo( 500+ sin(d) * 250,500 - cos(d) * 250,10);

glColor3f(0.9,0.6,0.2);

circulo( 500+ sin(e) * 300,500 + cos(e) * 300,18);

glColor3f(0.2,0.9,0.7);

circulo( 500+ sin(f) * 350,500 - cos(f) * 350,14);

glColor3f(0.2,0.7,0.9);

circulo( 500+ sin(ang) * 400,500 + cos(ang) * 400,12);

glColor3f(0.0,0.1,0.9);

circulo( 500+ sin(a) * 450,500 - cos(a) * 450,12);

a+=0.01; //a=a+0.1;

b+=0.02;

c+=0.03;

d+=0.04;

e+=0.05;

f+=0.06;

ang=ang+0.01; //velocidad entre mas grande mas rapido y entre menos mas lento

for(int j=1;j<=10000000;j++){}//pausa

if(ang==360){ang=0;}// se repite idefinidamente

glFlush(); //forzar dibujado

glutSwapBuffers(); //y esto

}

int main (int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA| GLUT_DEPTH);//esto tambien

glutInitWindowSize(1000,1000);

glutInitWindowPosition(10,10);

glutCreateWindow("Ventana");

inicializa();

glutDisplayFunc(dibuja);

glutIdleFunc(dibuja);//esto es lo que cambia

glutMainLoop();

return 0;

}

MOVIMIENTO EN OCHO.

Con círculos, se simulara un ocho, es decir pegar los círculos, para que dentro de estos, se mueva una pequeña bolita, que hará un movimiento en forma de ocho.

Código:

#include <unistd.h>

#include <GL/glut.h>

#include <GL/gl.h>

#include <math.h>

int x=1, x2=1,y=1;

double a=6.15, b=6.15;

void inicializa(void){

glClearColor(0.0,0.0,0.0,0.0);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluOrtho2D(0.0, 700.0, 0.0, 700.0);// el ancho y largo de nuestra pantalla

}

void circulo(int x, int y, int radio){

int angulo=0;

glBegin(GL_TRIANGLE_FAN);

glVertex2f(x,y);

for (angulo=0;angulo<=360; angulo+=6){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();}

void dibuja(void)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glColor3f(1.0, 1.0, 1.0);

circulo(300, 300, 70);

circulo(300,180,70);

glColor3f(0.0,0.0,0.0);

circulo(300,300,50);

circulo(300,180,50);

glColor3f(1.0,0.0,0.0);

if(a>=6.15 && a<=12.41){

circulo(300+ sin (a)*60,300- cos(a)*60,10);

a=a+0.01;

}

else{

circulo(300 + sin (b) *60,180-cos(b)*-60,10);

b=b + 0.14;

if(b>12.4){a=6.15;b=6.15;}

for(int j=0; j<=10000000; j++) {}

}

glFlush();

glutSwapBuffers();

}

int main (int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA| GLUT_DEPTH);

glutInitWindowSize(700,700);

glutInitWindowPosition(10,10);

glutCreateWindow("Ventana");

inicializa();

glutDisplayFunc(dibuja);

glutIdleFunc(dibuja);

glutMainLoop();

return 0;

}

SEMAFORO

En esta práctica realizaremos un semáforo en el cual los colores se cambien según la ubicación de dicho semáforo, para ello utilizaremos, rectángulos y círculos así como se muestra a continuación:

Código:

#include <unistd.h>

#include <GL/glut.h>

#include <GL/gl.h>

#include <math.h>

int rad=100;

double ang=0,a=0,b=0,c=0,d=0,e=0,f=0,g=0;

void inicializa(void)

{

glClearColor(0.2,0.6,0.8,1.0);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluOrtho2D(0.0, 500.0, 0.0, 500.0);// el ancho y largo de nuestra pantalla

}

void circuloc(int x, int y, int t, int radio)

{

int angulo=0;

glPointSize(t);

glBegin(GL_POINTS);

//glColor3f (1.0, 0.0, 1.0);

glVertex2f(x,y);

//glColor3f(0,0.0,0.0);

for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void circulo(int x, int y, int radio)

{

int angulo=0;

glBegin(GL_TRIANGLE_FAN);

glVertex2f(x,y);

for (angulo=0;angulo<=360; angulo++){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void dibuja(void)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto

glBegin(GL_QUADS);//Cuadros fondo semaforo

glColor3f(0.2 , 0.6 , 0.);

glVertex2i(170,437);

glVertex2i(320,437);

glVertex2i(320,182);

glVertex2i(170,182);

glVertex2i(229,183);

glVertex2i(278,183);

glVertex2i(278,3);

glVertex2i(229,3);

glEnd();

glColor3f(0.0,0.0,0.0);//Luces Roja

circulo(247,226,34);

glColor3f(0.0,0.0,0.0);//Luces Amarrilla

circulo(247,302,34);

glColor3f(0.0,0.0,0.0);//Luces Verde

circulo(247,381,34);

a=a+1; //velocidad entre mas grande mas rapido y entre menos mas lento

for(int j=1;j<=10000000;j++){}//pausa

if(a>1 && a<20){

glColor3f(1.0,0.0,0.0);//Luces Roja

circulo(247,381,34);

}// se repite idefinidamente

if(a>20 && a<40){

glColor3f(0.0,1.0,0.0);//Luces Roja

circulo(247,226,34);

}// se repite idefinidamente

if(a>40 && a<50){

glColor3f(1.0,1.0,0.0);//Luces Roja

circulo(247,302,34);

}// se repite idefinidamente

if(a>55 && a<50){

glColor3f(1.0,1.0,0.0);//Luces Roja

circulo(247,302,34);

}// se repite idefinidamente

if(a>60 && a<55){

glColor3f(1.0,1.0,0.0);//Luces Roja

circulo(247,302,34);

}// se repite idefinidamente

if(a>60){a=0;}

glFlush(); //forzar dibujado

glutSwapBuffers(); //y esto

}

int main (int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA| GLUT_DEPTH);//esto tambien

glutInitWindowSize(500,500);

glutInitWindowPosition(10,10);

glutCreateWindow("Ventana");

inicializa();

glutDisplayFunc(dibuja);

glutIdleFunc(dibuja);//esto es lo que cambia

glutMainLoop();

return 0;

}

CONCLUSION

Nos dimos cuenta que utilizar este programa no es

muy difícil ya que lo único que se tiene que hacer es colocar bien las coordenadas y las primitivas para que los archivos salgan de la manera que uno quiere por que si no se hace de la forma anterior no saldrán los trabajos como se desean, lo único que se nos dificulto fue la realización de algunas animaciones ya que se necesitan primitivas espaciales para que ocurra cierta animación.