Manual de actividades
-
Upload
alemartinez19 -
Category
Documents
-
view
342 -
download
1
description
Transcript of Manual de actividades
Cecytem Plantel Tecámac
Alejandra Martínez Valero
Sandy Moreno Rosas
Manual de prácticas
Grupo: 303
René Domínguez Escalona
Introducción OpenGL es una interface de software para el hardware grafico, esta interface consiste de una larga serie de comandos para manipulacion de objetos y operaciones sobre estos los cuales permiten controlar la implentacion realizada en la forma de una maquina de estados finitos, donde cada una de las variables que determinan el estado se aplican a partir de ese punto hasta que se indique explicitmanete el cambio, asi las variables de estado de OpenGL que vamos a utilizar mas comunmente son:
• Color (de dibujo y de borrado).
• Matrices de Transformacion (GL_MODELVIEW, GL_PROYECTION).
• Patrones (de lineas y de relleno).
• Modo de dibujo de poligonos.
• Buffers de dibujo.
• Buffer de Stencil.
• Buffer de profundidad (z-Buffer).
• Buffer de acumulacion.
Funcionamiento de OpenGL:
Para poder trabajar con OpenGL, primero se debe crear un contexto de trabajo, este contexto contiene el estado actual de maquina finita, asi como las referencias a los diferentes buffers de trabajo, estos buffers se pueden ver como zonas de memoria correspondiendo a la pantalla en las cuales OpenGL va a dibujar, en general a parte del
buffer de color (GL_COLOR_BUFFER) que es el buffer en el cual se van a dibujar las primitivas, existen otro tipo de buffers mas especializados. La configuracion en memoria de estos buffers (cuantos bits representan un pixel, etc) depende de la manera como fue creado el contexto OpenGL y de las limitaciones del hardware, por esto no se puede acceder directamente sino solo a traves de las primitivas OpenGL.
OpenGL puede funcionar adicionalmente de dos maneras, de modo directo o indirecto:
• Modo directo: las primitivas se van dibujando a medida que se van definiendo.
Instruccion -> Buffer de Color = Pantalla
• Modo indirecto: las primitivas se guardan en una lista y solo se dibujan cuando el usuario decida o la
lista este llena, esto permite optimizar la fase de dibujo.
Instruccion-> Pila de instrucciones-> flush -> Buffer de Color = Pantalla
En este modo cuando se desea que OpenGL pinte lo que esta en la lista se utiliza la instruccion glFlush(): esta instruccion obliga a pintar y no espera a que el hardawre termine para continuar con el programa, analogamente la glFinish() obliga a pintar pero espera a que el hw termine antes de continuar con el programa.
En el modo indirecto, OpenGL permite definir dos buffers de colores (doublebuffer), asi un buffer corresponde a lo que se ve en pantalla y otro a el buffer donde se esta pintando, de esta manera una vez que se ha pintado todo lo deseado y se quiere que esto aparezca en
pantalla se intercambian los buffers, esta instruccion depende del sistema operativo para esto se utilizara la instruccion de la libreria portable glut:
glutSwapBuffers() (esta ejecuta implicitamente glFlush o glFinish), en este modo glFlush y glFinish
obligan a pintar en el buffer de dibujo pero esto NO sera visible hasta intercambiar buffers. Primitivas de dibujo :
En OpenGL solo se pueden dibujar primitivas muy simples, tales como puntos lineas, cuadrados, triangulos y polygonos, a partir de estas primitivas es posible construir primitivas mas complejas como arcos y circulos aproximandolos por poligonos.
Toda primitiva de dibujo se construye con un par: glBegin(tipo_de_primitiva); glVertex2f(); ... glEnd();
donde tipo_de_primitiva puede ser cualquiera de las siguientes:
GL_POINTS: Cada vertice es un punto
GL_LINES: Cada par de vertices sucesivos es una linea
GL_LINE_STRIP: lineas conectadas.
GL_LINE_LOOP: lineas conectadas donde el ultimo y el primer vertice indican una linea cerrando el poligono.
GL_POLYGON: poligono (relleno o no) donde los vertices sucesivos componiendolo se dan el sentido contrario de las manecillas del reloj.
GL_QUADS: cuadrilateros separados, cada 4 vertices hacen un quad.
GL_QUAD_STRIP: tira de cuadrados unidos, cada par de vertices sucesivos forman un cuadrado con el par anterior.
GL_TRIANGLES: Triangulos separados, cada 3 vertices hacen un triangulo.
GL_TRIANGLE_STRIP: tira de triangulos unidos (similara quad_strip).
GL_TRIANGLE_FAN: Grupo de triangulos con un unico vertice comun a todos.
INDICE
1. Tablero de Ajedrez2. Estrella
3. Cubo con Líneas4. Cubo Delineado5. Muñeco con Triángulos6. Casita7. Oso8. Cubo con Cubitos9. Muñeco con formas
10.Animación de Circulo rotando11.Sistema Solar12.Movimiento en Ocho13.Semáforo14.Cubo 3D con Líneas15.Pirámide16.Nombre 3D
1. Tablero de Ajedrez
En esta práctica aprendimos a colocar cuadros con coordenadas un cuadro sobre otro y le cambiamos el color a modo de que pareciera un tablero de ajedrez. CODIGO://mi primer ventana#include <GL/glut.h>
#include <GL/gl.h>#include <GL/glu.h>
void inicializa(void){glClearColor(1.0,1.0,0.0,0.0); //color de fondoglMatrixMode(GL_PROJECTION); //Modo de proyeccion glLoadIdentity(); //Establece los parametros de proyecciongluOrtho2D(0.0, 1050.0, 0.0, 1000.0); //vista ortogonal}
void dibuja(void) //funcion dibuja{
glClear(GL_COLOR_BUFFER_BIT); //borra pantallaglColor3f(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 GLUTglutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualizaciónglutInitWindowSize(500,500); //tamaño de la ventanaglutInitWindowPosition(0,0); //posicion inicial de la ventanaglutCreateWindow("MI primer ventana"); //nombre de la ventanainicializa();
glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualizaciónglutMainLoop(); //muestra todo y esperareturn 0; //retorna un valor de cero}
2. EstrellaEn esta practica vimos como juntar puntos para realizar una figura en este
caso una estrella. CODIGO://mi primer ventana#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 fondoglMatrixMode(GL_PROJECTION); //Modo de proyeccion glLoadIdentity(); //Establece los parametros de proyecciongluOrtho2D(0.0, 1000.0, 0.0, 1000.0); //vista ortogonal}
void dibuja(void) //funcion dibuja{glClear(GL_COLOR_BUFFER_BIT); //borra pantallaglColor3f(0.0 , 0.0 , 0.0);glBegin(GL_LINES);glVertex2i(400,700);glVertex2i(700,100);glVertex2i(700,100);glVertex2i(100,500);glVertex2i(100,500);glVertex2i(800,500);
glVertex2i(800,500);glVertex2i(200,100);glVertex2i(200,100);glVertex2i(400,700);glEnd(); glFlush(); //forza dibujo}
int main (int argc, char** argv) //metodo main{
glutInit(&argc, argv); //incializa GLUTglutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualizaciónglutInitWindowSize(500,500); //tamaño de la ventanaglutInitWindowPosition(0,0); //posicion inicial de la ventanaglutCreateWindow("MI primer ventana"); //nombre de la ventanainicializa();glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización
glutMainLoop(); //muestra todo y esperareturn 0; //retorna un valor de cero
3. Cubo con líneas
En esta practica veremos como realizar un cubo con líneas de tal modo de que se vean todas las líneas sin delineado ni clores que obstruyan la vista de todas las
líneas que componen el cubo.
CODIGO:
//CUBO CON LINEAS #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 fondoglMatrixMode(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);glColor3f(1.0 ,0.0 ,1.0 );glBegin(GL_LINES);
glVertex2i(100,100);glVertex2i(100,400);glVertex2i(100,100);glVertex2i(400,100);
glVertex2i(400,100);glVertex2i(400,400);glVertex2i(400,400);
glVertex2i(100,400);glVertex2i(100,100);glVertex2i(300,300);
glVertex2i(100,400);glVertex2i(300,600);
glVertex2i(300,300);glVertex2i(300,600);
glVertex2i(300,300);glVertex2i(600,300);glVertex2i(600,600);glVertex2i(600,300);glVertex2i(600,600);glVertex2i(300,600);glVertex2i(600,600);glVertex2i(400,400);glVertex2i(600,300);glVertex2i(400,100);
glEnd();glFlush(); //forza dibujo}
int main (int argc, char** argv) //metodo main{glutInit(&argc, argv); //incializa GLUTglutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualizaciónglutInitWindowSize(500,500); //tamaño de la ventana
glutInitWindowPosition(0,0); //posicion inicial de la ventanaglutCreateWindow("MI primer ventana"); //nombre de la ventanainicializa();
glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualizaciónglutMainLoop(); //muestra todo y esperareturn 0; //retorna un valor de cero}
4. Cubo Delineado
En esta practica aprendimos a hacer un cubo con colores es decir que solo se ven tres partes del cubo y bien marcadas sus líneas.
CODIGO:
//cubo delineado #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 fondoglMatrixMode(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 pantallaglColor3f(1.0 , 1.0 , 0.0);glBegin(GL_QUADS);glColor3f(0.0,1.0,1.0);glVertex2i(100,100);glVertex2i(100,200);glVertex2i(200,200);
glVertex2i(200,100);
glColor3f(0.0,1.0,0.0);glVertex2i(200,100);glVertex2i(200,200);glVertex2i(250,250);glVertex2i(250,150);
glColor3f(1.0,0.0,0.0);glVertex2i(250,250);glVertex2i(150,250);glVertex2i(100,200);glVertex2i(200,200);
glEnd();glLineWidth(3);glBegin(GL_LINES);glColor3f(0.0,0.0,0.0);glVertex2i(100,100);glVertex2i(100,200);glVertex2i(200,200);glVertex2i(200,100);glVertex2i(100,200);glVertex2i(200,200);glVertex2i(100,100);glVertex2i(200,100);glVertex2i(200,200);
glVertex2i(200,100);
glVertex2i(100,200);glVertex2i(150,250);
glVertex2i(200,200);glVertex2i(250,250);
glVertex2i(200,100);glVertex2i(250,150);
glVertex2i(150,250);glVertex2i(250,250);
glVertex2i(250,250);glVertex2i(250,150);glEnd();
glFlush(); //forza dibujo
}
int main (int argc, char** argv) //metodo main{glutInit(&argc, argv); //incializa GLUTglutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualizaciónglutInitWindowSize(500,500); //tamaño de la ventanaglutInitWindowPosition(0,0); //posicion inicial de la ventanaglutCreateWindow("MI primer ventana"); //nombre de la ventanainicializa();
glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualizaciónglutMainLoop(); //muestra todo y esperareturn 0; //retorna un valor de cero
}
5. Muñeco con triángulos
En esta practica utilizamos varias figuras geométricas como lo que son triángulos, círculos, cuadrados, rectángulos para crear un muñeco utilizando dichas figuras.
CODIGO:
#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, 500.0, 0.0,500.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(0.0 ,0.0,1.0);
glBegin(GL_QUADS);
glVertex2i(0,500);
glVertex2i(500,500);
glVertex2i(500,114);
glVertex2i(0,114);
glColor3f(0.1 , 1.0 , 0.1);
glVertex2i(0,115);
glVertex2i(0,0);
glVertex2i(500,0);
glVertex2i(500,115);
glEnd();
glColor3f(2.0 , 1.0 , 2.0);
glLineWidth(4);
glBegin(GL_TRIANGLES);
glVertex2i(184,405);
glVertex2i(314,405);
glVertex2i(250,468);
glColor3f(0.9 , 0.0 , 1.0);
glVertex2i(215,405);
glVertex2i(287,405);
glVertex2i(250,335);
glColor3f(1.9 , 1.7 , 3.0);
glVertex2i(239,335);
glVertex2i(261,335);
glVertex2i(250,314);
glEnd();
glBegin(GL_QUADS);
glColor3f(0.0 , 1.0 , 1.0);
glVertex2i(208,335);
glVertex2i(292,335);
glVertex2i(293,241);
glVertex2i(208,241);
glEnd();
glBegin(GL_TRIANGLES);
glColor3f(0.0 , 0.7 , 0.5);
glVertex2i(239,335);
glVertex2i(261,335);
glVertex2i(250,314);
glColor3f(1.0 , 0.2 , 0.0);
glVertex2i(208,335);
glColor3f(1.0 , 1.0 , 3.0);
glVertex2i(170,241);
glColor3f(5.0 , 1.0 , 5.0);
glVertex2i(160,279);
glColor3f(1.0 , 0.7 , 1.0);
glVertex2i(160,279);
glColor3f(0.0 , 1.0 , 0.9);
glVertex2i(151,298);
glColor3f(0.0 , 0.3 , 1.0);
glVertex2i(142,260);
glColor3f(0.9 , 0.2 , 0.4);
glVertex2i(329,240);
glColor3f(1.0 , 1.0 , 1.0);
glVertex2i(339,279);
glColor3f(1.0 , 1.0 , 1.0);
glVertex2i(293,335);
glColor3f(0.1 , 0.8 , 0.4);
glVertex2i(348,297);
glColor3f(1.0 , 1.0 , 1.0);
glVertex2i(357,259);
glVertex2i(339,279);
glColor3f(1.0 , 0.9 , 0.6);
glVertex2i(333,326);
glVertex2i(391,326);
glVertex2i(362,247);
glColor3f(0.7 , 0.7 , 0.9);
glVertex2i(362,250);
glVertex2i(348,326);
glVertex2i(341,322);
glColor3f(0.4 , 0.6 , 0.8);
glVertex2i(377,326);
glVertex2i(384,322);
glVertex2i(364,250);
glColor3f(0.4 , 0.6 , 0.4);
glVertex2i(239,241);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(239,96);
glColor3f(1.0 , 1.0 , 1.0);
glVertex2i(214,210);
glColor3f(1.0 , 0.0 , 0.0);
glVertex2i(238,95);
glVertex2i(195,96);
glVertex2i(213,117);
glColor3f(0.9 , 0.7 , 0.5);
glVertex2i(256,241);
glColor3f(1.0 , 1.0 , 1.0);
glVertex2i(256,210);
glColor3f(1.0 , 1.0 , 1.0);
glVertex2i(299,210);
glColor3f(0.9 , 0.7 , 0.5);
glVertex2i(299,210);
glVertex2i(282,189);
glVertex2i(290,158);
glColor3f(1.0 , 0.0 , 0.3);
glVertex2i(292,158);
glVertex2i(316,178);
glVertex2i(333,158);
glColor3f(0.9 , 1.0 , 0.0);
glVertex2i(308,158);
glVertex2i(308,143);
glVertex2i(293,143);
glVertex2i(322,158);
glVertex2i(322,143);
glVertex2i(337,143);
glVertex2i(337,128);
glVertex2i(322,128);
glVertex2i(322,113);
glVertex2i(308,128);
glVertex2i(308,113);
glVertex2i(293,128);
glColor3f(1.0 , 0.9 , 1.0);
glVertex2i(362,246);
glVertex2i(383,239);
glVertex2i(341,239);
glEnd();
glBegin(GL_QUADS);
glColor3f(1.0 , 2.0 , 1.0);
glVertex2i(308,128);
glVertex2i(322,128);
glVertex2i(322,113);
glVertex2i(308,113);
glVertex2i(308,128);
glColor3f(1.0 , 4.0 , 1.0);
glVertex2i(308,143);
glVertex2i(322,143);
glVertex2i(322,128);
glVertex2i(322,143);
glVertex2i(322,128);
glVertex2i(337,128);
glVertex2i(337,143);
glVertex2i(322,143);
glVertex2i(322,157);
glVertex2i(308,157);
glVertex2i(308,143);
glVertex2i(308,143);
glVertex2i(308,128);
glVertex2i(293,128);
glVertex2i(293,143);
glEnd();
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(900,900); //tamaño de la ventana
glutInitWindowPosition(0,0); //posicion inicial de la ventana
glutCreateWindow("Muñeco con triangulos"); //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
}
6. Oso
En esta practica realizamos un oso con círculos y una línea es muy fácil sabiendo acomodar correctamente los círculos.
CODIGO:
#include <GL/glut.h>
#include <GL/gl.h>
#include <math.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, 500.0, 0.0, 500.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(0.6,0.4,0.2);
//Oso //borra pantalla
circulo(250,250,200);
//pies
circulo(100,100,50);
circulo(400,100,50);
// Manos
circulo(50,300,50);
circulo(450,300,50);
//Cabeza
circulo(250,350,150);
//orejas
circulo(400,450,50);
circulo(100,450,50);
//ojos
glColor3f(0.0,.0,0.0);
circulo(200,450,20);
circulo(300,450,20);
//nariz
circulo(260,370,25);
glEnd();
glLineWidth(50);
glBegin(GL_LINES);
glColor3f(0.0,0.0,0.0);
glVertex2i(200,325);
glVertex2i(350,325);
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(50,50); //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
}
7. Cubo con cubitosPara esta practica se necesita el cubo delineado de la practica anterior ya que lo
tienes en necesario saber acomodar bien los demás cubos ya que en esta practica ya es necesaria la combinación de formulas para poder hacer el cubo. También es
necesario definir las instrucciones al principio del programa de lo contrario no compilara.
CODIGO:
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{
glClearColor(0.5,0.0,.6,0.0); //color de fondo
glMatrixMode(GL_PROJECTION); //Modo de proyeccion
glLoadIdentity(); //Establece los parametros de proyeccion
gluOrtho2D(0.0, 4000.0, 0.0,4000.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{
int i,a=100;
glClear(GL_COLOR_BUFFER_BIT);
////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
for(i=0;i<=10;i++){
glColor3f(1.0 ,0.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(700,600+a*i);
glVertex2i(700,700+a*i);
//arriva
glVertex2i(750,750+a*i);
//derecha
glVertex2i(750,650+a*i);
glEnd();
glColor3f(1.0 ,0.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(600,600+a*i);
glVertex2i(600,700+a*i);
//arriva
glVertex2i(700,700+a*i);
//derecha
glVertex2i(700,600+a*i);
//abajo
glEnd();
glColor3f(.0 ,.0 ,.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(600,700+a*i);
glVertex2i(650,750+a*i);
//arriva
glVertex2i(750,750+a*i);
//derecha
glVertex2i(700,700+a*i);
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(600,600+a*i);
glVertex2i(600,700+a*i);
//arriva
glVertex2i(600,700+a*i);
glVertex2i(700,700+a*i);
//derecha
glVertex2i(700,700+a*i);
glVertex2i(700,600+a*i);
//abajo
glVertex2i(700,600+a*i);
glVertex2i(600,600+a*i);
//diagonal derecha esquina arriva
glVertex2i(650,750+a*i);
glVertex2i(600,700+a*i);
//linea cuadro atras
//linea cuadro atras
glVertex2i(650,750+a*i);
glVertex2i(750,750+a*i);
//linea derecha atras
glVertex2i(750,750+a*i);
glVertex2i(750,650+a*i);
//linea abajo derecha diagonal
glVertex2i(700,600+a*i);
glVertex2i(750,650+a*i);
//linea arriva derecha diagonal
glVertex2i(700,700+a*i);
glVertex2i(750,750+a*i);
glEnd();
}
////////////////////////////////////////////////////////////////////////
for(i=0;i<=10;i++){
glColor3f(1.0 ,1.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(1700,1600);
glVertex2i(1700,1700);
//arriva
glVertex2i(1750,1750);
//derecha
glVertex2i(1750,1650);
glEnd();
glColor3f(1.0 ,0.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1600-a*i,1600);
glVertex2i(1600-a*i,1700);
//arriva
glVertex2i(1700-a*i,1700);
//derecha
glVertex2i(1700-a*i,1600);
//abajo
glEnd();
glColor3f(0.0 ,1.0 ,0.5 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1600-a*i,1700);
glVertex2i(1650-a*i,1750);
//arriva
glVertex2i(1750-a*i,1750);
//derecha
glVertex2i(1700-a*i,1700);
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(1600-a*i,1600);
glVertex2i(1600-a*i,1700);
//arriva
glVertex2i(1600-a*i,1700);
glVertex2i(1700-a*i,1700);
//derecha
glVertex2i(1700-a*i,1700);
glVertex2i(1700-a*i,1600);
//abajo
glVertex2i(1700-a*i,1600);
glVertex2i(1600-a*i,1600);
//diagonal derecha esquina arriva
glVertex2i(1650-a*i,1750);
glVertex2i(1600-a*i,1700);
//linea cuadro atras
//linea cuadro atras
glVertex2i(1650-a*i,1750);
glVertex2i(1750-a*i,1750);
//linea derecha atras
glVertex2i(1750,1750);
glVertex2i(1750,1650);
//linea abajo derecha diagonal
glVertex2i(1700,1600);
glVertex2i(1750,1650);
//linea arriva derecha diagonal
glVertex2i(1700-a*i,1700);
glVertex2i(1750-a*i,1750);
glEnd();
}
///////////////////////////////////////////////////////////////////////
for(i=0;i<=9;i++){
glColor3f(1.0 ,1.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(1700,600);
glVertex2i(1700,700);
//arriva
glVertex2i(1750,750);
//derecha
glVertex2i(1750,650);
glEnd();
glColor3f(1.0 ,0.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1600-a*i,600);
glVertex2i(1600-a*i,700);
//arriva
glVertex2i(1700-a*i,700);
//derecha
glVertex2i(1700-a*i,600);
//abajo
glEnd();
glColor3f(0.0 ,1.0 ,0.5 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1600-a*i,700);
glVertex2i(1650-a*i,750);
//arriva
glVertex2i(1750-a*i,750);
//derecha
glVertex2i(1700-a*i,700);
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(1600-a*i,600);
glVertex2i(1600-a*i,700);
//arriva
glVertex2i(1600-a*i,700);
glVertex2i(1700-a*i,700);
//derecha
glVertex2i(1700-a*i,700);
glVertex2i(1700-a*i,600);
//abajo
glVertex2i(1700-a*i,600);
glVertex2i(1600-a*i,600);
//diagonal derecha esquina arriva
glVertex2i(1650-a*i,750);
glVertex2i(1600-a*i,700);
//linea cuadro atras
//linea cuadro atras
glVertex2i(1650-a*i,750);
glVertex2i(1750-a*i,750);
//linea derecha atras
glVertex2i(1750,750);
glVertex2i(1750,650);
//linea abajo derecha diagonal
glVertex2i(1700,600);
glVertex2i(1750,650);
//linea arriva derecha diagonal
glVertex2i(1700-a*i,700);
glVertex2i(1750-a*i,750);
glEnd();
}
//////////////////////////////////////////////////////////////////////
for(i=0;i<=10;i++){
glColor3f(1.0 ,1.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(1700,600+a*i);
glVertex2i(1700,700+a*i);
//arriva
glVertex2i(1750,750+a*i);
//derecha
glVertex2i(1750,650+a*i);
glEnd();
glColor3f(1.0 ,0.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1600,600+a*i);
glVertex2i(1600,700+a*i);
//arriva
glVertex2i(1700,700+a*i);
//derecha
glVertex2i(1700,600+a*i);
//abajo
glEnd();
glColor3f(0.0 ,6.0 ,0.5 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1600,700+a*i);
glVertex2i(1650,750+a*i);
//arriva
glVertex2i(1750,750+a*i);
//derecha
glVertex2i(1700,700+a*i);
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(1600,600+a*i);
glVertex2i(1600,700+a*i);
//arriva
glVertex2i(1600,700+a*i);
glVertex2i(1700,700+a*i);
//derecha
glVertex2i(1700,700+a*i);
glVertex2i(1700,600+a*i);
//abajo
glVertex2i(1700,600+a*i);
glVertex2i(1600,600+a*i);
//diagonal derecha esquina arriva
glVertex2i(1650,750+a*i);
glVertex2i(1600,700+a*i);
//linea cuadro atras
//linea cuadro atras
glVertex2i(1650,750+a*i);
glVertex2i(1750,750+a*i);
//linea derecha atras
glVertex2i(1750,750+a*i);
glVertex2i(1750,650+a*i);
//linea abajo derecha diagonal
glVertex2i(1700,600+a*i);
glVertex2i(1750,650+a*i);
//linea arriva derecha diagonal
glVertex2i(1700,700+a*i);
glVertex2i(1750,750+a*i);
glEnd();
}
//////////////////////////////////////////////////////////////////////
for(i=0;i<=9;i++){
glColor3f(1.0 ,1.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(200+(50*i),100+(50*i));
glVertex2i(200+(50*i),200+(50*i));
//arriva
glVertex2i(250+(50*i),250+(50*i));
//derecha
glVertex2i(250+(50*i),150+(50*i));
glEnd();
glColor3f(1.0 ,0.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(100,100);
glVertex2i(100,200);
//arriva
glVertex2i(200,200);
//derecha
glVertex2i(200,100);
//abajo
glEnd();
glColor3f(0.0 ,1.0 ,0.5 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(100+(50*i),200+(50*i));
glVertex2i(150+(50*i),250+(50*i));
//arriva
glVertex2i(250+(50*i),250+(50*i));
//derecha
glVertex2i(200+(50*i),200+(50*i));
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(100,100);
glVertex2i(100,200);
//arriva
glVertex2i(100+(50*i),200+(50*i));
glVertex2i(200+(50*i),200+(50*i));
//derecha
glVertex2i(200+(50*i),200+(50*i));
glVertex2i(200+(50*i),100+(50*i));
//abajo
glVertex2i(200,100);
glVertex2i(100,100);
//diagonal derecha esquina arriva
glVertex2i(150+(50*i),250+(50*i));
glVertex2i(100+(50*i),200+(50*i));
//linea cuadro atras
//linea cuadro atras
glVertex2i(150+(50*i),250+(50*i));
glVertex2i(250+(50*i),250+(50*i));
//linea derecha atras
glVertex2i(250+(50*i),250+(50*i));
glVertex2i(250+(50*i),150+(50*i));
//linea abajo derecha diagonal
glVertex2i(200+(50*i),100+(50*i));
glVertex2i(250+(50*i),150+(50*i));
//linea arriva derecha diagonal
glVertex2i(200+(50*i),200+(50*i));
glVertex2i(250+(50*i),250+(50*i));
glEnd();
}
///////////////////////////////////////////////////////
for(i=0;i<=9;i++){
glColor3f(1.0 ,1.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(1200+(50*i),100+(50*i));
glVertex2i(1200+(50*i),200+(50*i));
//arriva
glVertex2i(1250+(50*i),250+(50*i));
//derecha
glVertex2i(1250+(50*i),150+(50*i));
glEnd();
glColor3f(1.0 ,0.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100,100);
glVertex2i(1100,200);
//arriva
glVertex2i(1200,200);
//derecha
glVertex2i(1200,100);
//abajo
glEnd();
glColor3f(0.0 ,1.0 ,0.5 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100+(50*i),200+(50*i));
glVertex2i(1150+(50*i),250+(50*i));
//arriva
glVertex2i(1250+(50*i),250+(50*i));
//derecha
glVertex2i(1200+(50*i),200+(50*i));
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(1100,100);
glVertex2i(1100,200);
//arriva
glVertex2i(1100+(50*i),200+(50*i));
glVertex2i(1200+(50*i),200+(50*i));
//derecha
glVertex2i(1200+(50*i),200+(50*i));
glVertex2i(1200+(50*i),100+(50*i));
//abajo
glVertex2i(1200,100);
glVertex2i(1100,100);
//diagonal derecha esquina arriva
glVertex2i(1150+(50*i),250+(50*i));
glVertex2i(1100+(50*i),200+(50*i));
//linea cuadro atras
//linea cuadro atras
glVertex2i(1150+(50*i),250+(50*i));
glVertex2i(1250+(50*i),250+(50*i));
//linea derecha atras
glVertex2i(1250+(50*i),250+(50*i));
glVertex2i(1250+(50*i),150+(50*i));
//linea abajo derecha diagonal
glVertex2i(1200+(50*i),100+(50*i));
glVertex2i(1250+(50*i),150+(50*i));
//linea arriva derecha diagonal
glVertex2i(1200+(50*i),200+(50*i));
glVertex2i(1250+(50*i),250+(50*i));
glEnd();
}
////////////////////////////////////////////////////////
for(i=0;i<=9;i++){
glColor3f(1.0 ,1.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(200+(50*i),1100+(50*i));
glVertex2i(200+(50*i),1200+(50*i));
//arriva
glVertex2i(250+(50*i),1250+(50*i));
//derecha
glVertex2i(250+(50*i),1150+(50*i));
glEnd();
glColor3f(1.0 ,0.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(100,1100);
glVertex2i(100,1200);
//arriva
glVertex2i(200,1200);
//derecha
glVertex2i(200,1100);
//abajo
glEnd();
glColor3f(0.0 ,11.0 ,0.5 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(100+(50*i),1200+(50*i));
glVertex2i(150+(50*i),1250+(50*i));
//arriva
glVertex2i(250+(50*i),1250+(50*i));
//derecha
glVertex2i(200+(50*i),1200+(50*i));
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(100,1100);
glVertex2i(100,1200);
//arriva
glVertex2i(100+(50*i),1200+(50*i));
glVertex2i(200+(50*i),1200+(50*i));
//derecha
glVertex2i(200+(50*i),1200+(50*i));
glVertex2i(200+(50*i),1100+(50*i));
//abajo
glVertex2i(200,1100);
glVertex2i(100,1100);
//diagonal derecha esquina arriva
glVertex2i(150+(50*i),1250+(50*i));
glVertex2i(100+(50*i),1200+(50*i));
//linea cuadro atras
//linea cuadro atras
glVertex2i(150+(50*i),1250+(50*i));
glVertex2i(250+(50*i),1250+(50*i));
//linea derecha atras
glVertex2i(250+(50*i),1250+(50*i));
glVertex2i(250+(50*i),1150+(50*i));
//linea abajo derecha diagonal
glVertex2i(200+(50*i),1100+(50*i));
glVertex2i(250+(50*i),1150+(50*i));
//linea arriva derecha diagonal
glVertex2i(200+(50*i),1200+(50*i));
glVertex2i(250+(50*i),1250+(50*i));
glEnd();
}
////////////////////////////////////////////////////////////
for(i=0;i<=9;i++){
glColor3f(1.0 ,1.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(1200+(50*i),1100+(50*i));
glVertex2i(1200+(50*i),1200+(50*i));
//arriva
glVertex2i(1250+(50*i),1250+(50*i));
//derecha
glVertex2i(1250+(50*i),1150+(50*i));
glEnd();
glColor3f(1.0 ,0.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100,1100);
glVertex2i(1100,1200);
//arriva
glVertex2i(1200,1200);
//derecha
glVertex2i(1200,1100);
//abajo
glEnd();
glColor3f(0.0 ,11.0 ,0.5 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100+(50*i),1200+(50*i));
glVertex2i(1150+(50*i),1250+(50*i));
//arriva
glVertex2i(1250+(50*i),1250+(50*i));
//derecha
glVertex2i(1200+(50*i),1200+(50*i));
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(1100,1100);
glVertex2i(1100,1200);
//arriva
glVertex2i(1100+(50*i),1200+(50*i));
glVertex2i(1200+(50*i),1200+(50*i));
//derecha
glVertex2i(1200+(50*i),1200+(50*i));
glVertex2i(1200+(50*i),1100+(50*i));
//abajo
glVertex2i(1200,1100);
glVertex2i(1100,1100);
//diagonal derecha esquina arriva
glVertex2i(1150+(50*i),1250+(50*i));
glVertex2i(1100+(50*i),1200+(50*i));
//linea cuadro atras
//linea cuadro atras
glVertex2i(1150+(50*i),1250+(50*i));
glVertex2i(1250+(50*i),1250+(50*i));
//linea derecha atras
glVertex2i(1250+(50*i),1250+(50*i));
glVertex2i(1250+(50*i),1150+(50*i));
//linea abajo derecha diagonal
glVertex2i(1200+(50*i),1100+(50*i));
glVertex2i(1250+(50*i),1150+(50*i));
//linea arriva derecha diagonal
glVertex2i(1200+(50*i),1200+(50*i));
glVertex2i(1250+(50*i),1250+(50*i));
glEnd();
}
//////////////////////////////////////////////////////////////////////
for(i=0;i<=10;i++){
glColor3f(1.0 ,1.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(200,100+a*i);
glVertex2i(200,200+a*i);
//arriva
glVertex2i(250,250+a*i);
//derecha
glVertex2i(250,150+a*i);
glEnd();
glColor3f(1.0 ,0.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(100,100+a*i);
glVertex2i(100,200+a*i);
//arriva
glVertex2i(200,200+a*i);
//derecha
glVertex2i(200,100+a*i);
//abajo
glEnd();
glColor3f(0.0 ,1.0 ,0.5 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(100,200+a*i);
glVertex2i(150,250+a*i);
//arriva
glVertex2i(250,250+a*i);
//derecha
glVertex2i(200,200+a*i);
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(100,100+a*i);
glVertex2i(100,200+a*i);
//arriva
glVertex2i(100,200+a*i);
glVertex2i(200,200+a*i);
//derecha
glVertex2i(200,200+a*i);
glVertex2i(200,100+a*i);
//abajo
glVertex2i(200,100+a*i);
glVertex2i(100,100+a*i);
//diagonal derecha esquina arriva
glVertex2i(150,250+a*i);
glVertex2i(100,200+a*i);
//linea cuadro atras
//linea cuadro atras
glVertex2i(150,250+a*i);
glVertex2i(250,250+a*i);
//linea derecha atras
glVertex2i(250,250+a*i);
glVertex2i(250,150+a*i);
//linea abajo derecha diagonal
glVertex2i(200,100+a*i);
glVertex2i(250,150+a*i);
//linea arriva derecha diagonal
glVertex2i(200,200+a*i);
glVertex2i(250,250+a*i);
glEnd();
}
//////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
for(i=0;i<=9;i++){
glColor3f(1.0 ,1.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(1200,1100);
glVertex2i(1200,1200);
//arriva
glVertex2i(1250,1250);
//derecha
glVertex2i(1250,1150);
glEnd();
glColor3f(1.0 ,0.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100-a*i,1100);
glVertex2i(1100-a*i,1200);
//arriva
glVertex2i(1200-a*i,1200);
//derecha
glVertex2i(1200-a*i,1100);
//abajo
glEnd();
glColor3f(0.0 ,1.0 ,0.5 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100-a*i,1200);
glVertex2i(1150-a*i,1250);
//arriva
glVertex2i(1250-a*i,1250);
//derecha
glVertex2i(1200-a*i,1200);
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(1100-a*i,1100);
glVertex2i(1100-a*i,1200);
//arriva
glVertex2i(1100-a*i,1200);
glVertex2i(1200-a*i,1200);
//derecha
glVertex2i(1200-a*i,1200);
glVertex2i(1200-a*i,1100);
//abajo
glVertex2i(1200-a*i,1100);
glVertex2i(1100-a*i,1100);
//diagonal derecha esquina arriva
glVertex2i(1150-a*i,1250);
glVertex2i(1100-a*i,1200);
//linea cuadro atras
//linea cuadro atras
glVertex2i(1150-a*i,1250);
glVertex2i(1250-a*i,1250);
//linea derecha atras
glVertex2i(1250,1250);
glVertex2i(1250,1150);
//linea abajo derecha diagonal
glVertex2i(1200,1100);
glVertex2i(1250,1150);
//linea arriva derecha diagonal
glVertex2i(1200-a*i,1200);
glVertex2i(1250-a*i,1250);
glEnd();
}
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
for(i=0;i<=9;i++){
glColor3f(1.0 ,1.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(1200,100);
glVertex2i(1200,200);
//arriva
glVertex2i(1250,250);
//derecha
glVertex2i(1250,150);
glEnd();
glColor3f(1.0 ,0.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100-a*i,100);
glVertex2i(1100-a*i,200);
//arriva
glVertex2i(1200-a*i,200);
//derecha
glVertex2i(1200-a*i,100);
//abajo
glEnd();
glColor3f(0.0 ,1.0 ,0.5 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100-a*i,200);
glVertex2i(1150-a*i,250);
//arriva
glVertex2i(1250-a*i,250);
//derecha
glVertex2i(1200-a*i,200);
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(1100-a*i,100);
glVertex2i(1100-a*i,200);
//arriva
glVertex2i(1100-a*i,200);
glVertex2i(1200-a*i,200);
//derecha
glVertex2i(1200-a*i,200);
glVertex2i(1200-a*i,100);
//abajo
glVertex2i(1200-a*i,100);
glVertex2i(1100-a*i,100);
//diagonal derecha esquina arriva
glVertex2i(1150-a*i,250);
glVertex2i(1100-a*i,200);
//linea cuadro atras
//linea cuadro atras
glVertex2i(1150-a*i,250);
glVertex2i(1250-a*i,250);
//linea derecha atras
glVertex2i(1250,250);
glVertex2i(1250,150);
//linea abajo derecha diagonal
glVertex2i(1200,100);
glVertex2i(1250,150);
//linea arriva derecha diagonal
glVertex2i(1200-a*i,200);
glVertex2i(1250-a*i,250);
glEnd();
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
for(i=0;i<=10;i++){
glColor3f(1.0 ,1.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(1200,100+a*i);
glVertex2i(1200,200+a*i);
//arriva
glVertex2i(1250,250+a*i);
//derecha
glVertex2i(1250,150+a*i);
glEnd();
glColor3f(1.0 ,0.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100,100+a*i);
glVertex2i(1100,200+a*i);
//arriva
glVertex2i(1200,200+a*i);
//derecha
glVertex2i(1200,100+a*i);
//abajo
glEnd();
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100,200+a*i);
glVertex2i(1150,250+a*i);
//arriva
glVertex2i(1250,250+a*i);
//derecha
glVertex2i(1200,200+a*i);
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(1100,100+a*i);
glVertex2i(1100,200+a*i);
//arriva
glVertex2i(1100,200+a*i);
glVertex2i(1200,200+a*i);
//derecha
glVertex2i(1200,200+a*i);
glVertex2i(1200,100+a*i);
//abajo
glVertex2i(1200,100+a*i);
glVertex2i(1100,100+a*i);
//diagonal derecha esquina arriva
glVertex2i(1150,250+a*i);
glVertex2i(1100,200+a*i);
//linea cuadro atras
//linea cuadro atras
glVertex2i(1150,250+a*i);
glVertex2i(1250,250+a*i);
//linea derecha atras
glVertex2i(1250,250+a*i);
glVertex2i(1250,150+a*i);
//linea abajo derecha diagonal
glVertex2i(1200,100+a*i);
glVertex2i(1250,150+a*i);
//linea arriva derecha diagonal
glVertex2i(1200,200+a*i);
glVertex2i(1250,250+a*i);
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("cubo3d"); //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
}
8. Animación circulo
En esta practica aprendimos a que una pelota se mueva y pase por las 4 partes de la ventana. También es importante que no se olvide definir nueva instrucción al
principio ya que de lo contrario el programa no compilara.
CODIGO:
#include <unistd.h>
#include <GL/glut.h>
#include <GL/gl.h>
#include <math.h>
int x=1,z=1,w=1, y=1;
void inicializa(void)
{
glClearColor(1.0,0.2,1.0,0.5);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 1200.0, 0.0, 800.0);// el ancho y largo de nuestra pantalla
}
void circulo(int x, int y, int radio)
{
int angulo=0;
glBegin(GL_TRIANGLE_FAN); glColor3f (2.0, 0.1, 3.0);
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);
if(x>=1 && x<1000){
circulo(2+1*x,700,40);
glFlush();
x++;
}
if(y>=1 && y<600 && x==1000){
circulo(1000,700-y,40);
glFlush();
y++;
}
if(w>=1 && w<1000 && y==600 && x==1000){
circulo(1000-w,100,40);
glFlush();
w++;
}
if(z>=1 && z<1000 && y==600 && x==1000 && w==1000){
circulo(5,100+z,40);
glFlush();
z++;
if(z==600) {z=1;x=1;y=1;w=1;}
}
glutSwapBuffers();
}
int main (int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA| GLUT_DEPTH);
glutInitWindowSize(1200,800);
glutInitWindowPosition(10,10);
glutCreateWindow("Ventana");
inicializa();
glutDisplayFunc(dibuja);
glutIdleFunc(dibuja);
glutMainLoop();
return 0;
}
9. Animación sistema solarEn esta practica del sistema solar hicimos una representación de dicho sistema haciendo que los planetas de movieran alrededor del sol. Es importante definir nuevas instrucciones al inicio.
CODIGO:
#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,h=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 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
circulo( 500+ sin(ang) * rad,500 + cos(ang) * rad,10); //funcion circulo
//sol
glColor3f(1.0,1.0,0.0);
circulo( 500,500,50);
//mercurio
circuloc(500,500,2,50);
glColor3f(1.6,0.0,0.5);
circulo( 500 + sin(a) * 100,500 + cos(a) * 100,5);
//venus
circuloc(500,500,2,100);
glColor3f(1.0,1.9,0.5);
circulo( 500+ sin(b) * 150,500 + cos(b) * 150,20);
//tierra
circuloc(500,500,2,150);
glColor3f(0.0,1.3,0.5);
circulo( 500+ sin(c) * 200,500 + cos(c) * 200,10);
//marte
circuloc(500,500,2,200);
glColor3f(1.0,1.0,0.5);
circulo( 500 + sin(d) * 250,500 + cos(d) * 250,15);
//jupiter
circuloc(500,500,2,250);
glColor3f(0.0,0.0,0.5);
circulo( 500 + sin(e) * 300,500 + cos(e) * 300,30);
//saturno
circuloc(500,500,2,300);
glColor3f(1.0,0.3,0.5);
circulo( 500+ sin(f) * 350,500 + cos(f) * 350,25);
//urano
circuloc(500,500,2,350);
glColor3f(1.0,0.9,0.0);
circulo( 500+ sin(g) * 400,500 + cos(g) * 400,13);
//neptuno
circuloc(500,500,2,400);
glColor3f(1.5,0.0,0.5);
circulo( 500 + sin(h) * 450,500 + cos(h) * 450,7);
circuloc(500,500,2,450);
a=a+0.01;
b=b+0.02;
c=c+0.08;
d=d+0.07;
e=e+0.04;
f=f+0.06;
g=g+0.03;
h=h+0.05;
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;
}
10. Movimiento en ochoEn esta práctica veremos como podemos hacer que un circulo se mueva alrededor de otros dos haciendo un movimiento circular en forma de un ocho.
CODIGO:
#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, 0.5, 1.0);
circulo(300, 300, 70);
circulo(300,180,70);
glColor3f(0.1,2.0,0.5);
circulo(300,300,50);
circulo(300,180,50);
glColor3f(0.0,1.0,3.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.25;
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;
}
15. PiramideEn esta practica realizamos una pirámide que vista desde arriba se ve en 3D Se
realiza con puras líneas.
CODIGO:
#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, 1050.0, 0.0, 1000.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{int i,a=20;
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 , 1.0 , 0.6);
glLineWidth(2);
glBegin(GL_LINES);
//valor inicial----valor final
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);
}
int c,s=40;
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
for(c=0;c<=4;c++){
glVertex2i(280+s*c,280+s*c);
glVertex2i(300+s*c,300+s*c);
glVertex2i(200-s*c,200-s*c);
glVertex2i(220-s*c,220-s*c);
glVertex2i(220-s*c,280+s*c);
glVertex2i(200-s*c,300+s*c);
glVertex2i(280+s*c,220-s*c);
glVertex2i(300+s*c,200-s*c);
}
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
}