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 Ajedrez
2. Estrella
3. Cubo con Líneas
4. Cubo Delineado
5. Muñeco con Triángulos
6. Casita
7. Oso
8. Cubo con Cubitos
9. Muñeco con formas
10.Animación de Circulo rotando
11.Sistema Solar
12.Movimiento en Ocho
13.Semáforo
14.Cubo 3D con Líneas
15.Pirámide
16.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 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);


glEnd();
glColor3f(1.0 , 1.0 , 1.0);
glPointSize(60);
glBegin(GL_POINTS);
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
}

2. Estrella
En esta practica vimos como juntar puntos para realizar una figura en este
caso una estrella.

CODIGO:
//mi primer ventana
#include <GL/gl.h>
#include <GL/glu.h>

{
}

{
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_LINES);
glEnd();
}

{
inicializa();


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/gl.h>
#include <GL/glu.h>

{
}

{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0 ,0.0 ,1.0 );
glBegin(GL_LINES);





glEnd();
}

{
inicializa();

}

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/gl.h>
#include <GL/glu.h>

{

}

{
glColor3f(1.0 , 1.0 , 0.0);
glBegin(GL_QUADS);
glColor3f(0.0,1.0,1.0);

glColor3f(0.0,1.0,0.0);

glColor3f(1.0,0.0,0.0);
glEnd();
glLineWidth(3);
glBegin(GL_LINES);
glColor3f(0.0,0.0,0.0);





glEnd();


}

{
inicializa();

}

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/gl.h>

#include <GL/glu.h>


{




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

}


{


glColor3f(0.0 ,0.0,1.0);

glBegin(GL_QUADS);

glVertex2i(0,500);



glVertex2i(0,114);

glColor3f(0.1 , 1.0 , 0.1);

glVertex2i(0,115);

glVertex2i(0,0);

glVertex2i(500,0);


glEnd();

glColor3f(2.0 , 1.0 , 2.0);

glLineWidth(4);

glBegin(GL_TRIANGLES);




glColor3f(0.9 , 0.0 , 1.0);




glColor3f(1.9 , 1.7 , 3.0);




glEnd();

glBegin(GL_QUADS);

glColor3f(0.0 , 1.0 , 1.0);





glEnd();

glBegin(GL_TRIANGLES);

glColor3f(0.0 , 0.7 , 0.5);




glColor3f(1.0 , 0.2 , 0.0);


glColor3f(1.0 , 1.0 , 3.0);


glColor3f(5.0 , 1.0 , 5.0);


glColor3f(1.0 , 0.7 , 1.0);


glColor3f(0.0 , 1.0 , 0.9);


glColor3f(0.0 , 0.3 , 1.0);


glColor3f(0.9 , 0.2 , 0.4);


glColor3f(1.0 , 1.0 , 1.0);


glColor3f(1.0 , 1.0 , 1.0);


glColor3f(0.1 , 0.8 , 0.4);


glColor3f(1.0 , 1.0 , 1.0);



glColor3f(1.0 , 0.9 , 0.6);




glColor3f(0.7 , 0.7 , 0.9);




glColor3f(0.4 , 0.6 , 0.8);




glColor3f(0.4 , 0.6 , 0.4);


glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(239,96);

glColor3f(1.0 , 1.0 , 1.0);


glColor3f(1.0 , 0.0 , 0.0);

glVertex2i(238,95);

glVertex2i(195,96);


glColor3f(0.9 , 0.7 , 0.5);


glColor3f(1.0 , 1.0 , 1.0);


glColor3f(1.0 , 1.0 , 1.0);


glColor3f(0.9 , 0.7 , 0.5);




glColor3f(1.0 , 0.0 , 0.3);




glColor3f(0.9 , 1.0 , 0.0);













glColor3f(1.0 , 0.9 , 1.0);




glEnd();

glBegin(GL_QUADS);

glColor3f(1.0 , 2.0 , 1.0);






glColor3f(1.0 , 4.0 , 1.0);
















glEnd();

glEnd();


}


{





glutCreateWindow("Muñeco con triangulos"); //nombre de la ventana

inicializa();




}

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/gl.h>

#include <math.h>


{





}

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


glEnd();

}


{


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



glEnd();


}


{





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

inicializa();




}

7. Cubo con cubitos
Para 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/gl.h>

#include <GL/glu.h>


{

glClearColor(0.5,0.0,.6,0.0); //color de fondo



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

}


{

int i,a=100;


////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////

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

glColor3f(1.0 ,0.0 ,1.0 );

glLineWidth(8);

glBegin(GL_QUADS);

//izquierda

glVertex2i(700,600+a*i);


//arriva


//derecha


glEnd();

glColor3f(1.0 ,0.0 ,1.0 );

glLineWidth(8);

glBegin(GL_QUADS);

//cuadro

//izquierda



//arriva


//derecha


//abajo

glEnd();

glColor3f(.0 ,.0 ,.0 );

glLineWidth(8);

glBegin(GL_QUADS);

//cuadro

//izquierda



//arriva


//derecha


//abajo

glEnd();

//cuadro

glColor3f(0.0 ,0.0 ,0.0 );

glLineWidth(4);

glBegin(GL_LINES);

//cuadro

//izquierda



//arriva



//derecha



//abajo



//diagonal derecha esquina arriva



//linea cuadro atras




//linea derecha atras



//linea abajo derecha diagonal



//linea arriva derecha diagonal



glEnd();

}

////////////////////////////////////////////////////////////////////////

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

glColor3f(1.0 ,1.0 ,1.0 );

glLineWidth(8);

glBegin(GL_QUADS);

//izquierda



//arriva


//derecha


glEnd();

glColor3f(1.0 ,0.0 ,1.0 );

glLineWidth(8);

glBegin(GL_QUADS);

//cuadro

//izquierda

glVertex2i(1600-a*i,1600);


//arriva


//derecha


//abajo

glEnd();

glColor3f(0.0 ,1.0 ,0.5 );

glLineWidth(8);

glBegin(GL_QUADS);

//cuadro

//izquierda



//arriva


//derecha


//abajo

glEnd();

//cuadro

glColor3f(0.0 ,0.0 ,0.0 );

glLineWidth(4);

glBegin(GL_LINES);

//cuadro

//izquierda



//arriva



//derecha



//abajo



















glEnd();

}

///////////////////////////////////////////////////////////////////////

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

glColor3f(1.0 ,1.0 ,1.0 );

glLineWidth(8);

glBegin(GL_QUADS);

//izquierda



//arriva


//derecha


glEnd();

glColor3f(1.0 ,0.0 ,1.0 );

glLineWidth(8);

glBegin(GL_QUADS);

//cuadro

//izquierda



//arriva


//derecha


//abajo

glEnd();

glColor3f(0.0 ,1.0 ,0.5 );

glLineWidth(8);

glBegin(GL_QUADS);

//cuadro

//izquierda



//arriva


//derecha


//abajo

glEnd();

//cuadro

glColor3f(0.0 ,0.0 ,0.0 );

glLineWidth(4);

glBegin(GL_LINES);

//cuadro

//izquierda



//arriva



//derecha



//abajo



















glEnd();

}

//////////////////////////////////////////////////////////////////////

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

glColor3f(1.0 ,1.0 ,1.0 );

glLineWidth(8);

glBegin(GL_QUADS);

//izquierda



//arriva


//derecha


glEnd();

glColor3f(1.0 ,0.0 ,1.0 );

glLineWidth(8);

glBegin(GL_QUADS);

//cuadro

//izquierda



//arriva


//derecha


//abajo

glEnd();

glColor3f(0.0 ,6.0 ,0.5 );

glLineWidth(8);

glBegin(GL_QUADS);

//cuadro

//izquierda



//arriva


//derecha


//abajo

glEnd();

//cuadro

glColor3f(0.0 ,0.0 ,0.0 );

glLineWidth(4);

glBegin(GL_LINES);

//cuadro

//izquierda



//arriva



//derecha



//abajo



















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



//arriva


//derecha


//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



//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(150+(50*i),250+(50*i));

glVertex2i(100+(50*i),200+(50*i));



glVertex2i(150+(50*i),250+(50*i));

glVertex2i(250+(50*i),250+(50*i));


glVertex2i(250+(50*i),250+(50*i));

glVertex2i(250+(50*i),150+(50*i));


glVertex2i(200+(50*i),100+(50*i));

glVertex2i(250+(50*i),150+(50*i));


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



//arriva


//derecha


//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



//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(1150+(50*i),250+(50*i));

glVertex2i(1100+(50*i),200+(50*i));



glVertex2i(1150+(50*i),250+(50*i));

glVertex2i(1250+(50*i),250+(50*i));


glVertex2i(1250+(50*i),250+(50*i));

glVertex2i(1250+(50*i),150+(50*i));


glVertex2i(1200+(50*i),100+(50*i));

glVertex2i(1250+(50*i),150+(50*i));


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



//arriva


//derecha


//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



//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(150+(50*i),1250+(50*i));

glVertex2i(100+(50*i),1200+(50*i));



glVertex2i(150+(50*i),1250+(50*i));

glVertex2i(250+(50*i),1250+(50*i));


glVertex2i(250+(50*i),1250+(50*i));

glVertex2i(250+(50*i),1150+(50*i));


glVertex2i(200+(50*i),1100+(50*i));

glVertex2i(250+(50*i),1150+(50*i));


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



//arriva


//derecha


//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



//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(1150+(50*i),1250+(50*i));

glVertex2i(1100+(50*i),1200+(50*i));



glVertex2i(1150+(50*i),1250+(50*i));

glVertex2i(1250+(50*i),1250+(50*i));


glVertex2i(1250+(50*i),1250+(50*i));

glVertex2i(1250+(50*i),1150+(50*i));


glVertex2i(1200+(50*i),1100+(50*i));

glVertex2i(1250+(50*i),1150+(50*i));


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



//arriva


//derecha


glEnd();

glColor3f(1.0 ,0.0 ,1.0 );

glLineWidth(8);

glBegin(GL_QUADS);

//cuadro

//izquierda



//arriva


//derecha


//abajo

glEnd();

glColor3f(0.0 ,1.0 ,0.5 );

glLineWidth(8);

glBegin(GL_QUADS);

//cuadro

//izquierda



//arriva


//derecha


//abajo

glEnd();

//cuadro

glColor3f(0.0 ,0.0 ,0.0 );

glLineWidth(4);

glBegin(GL_LINES);

//cuadro

//izquierda



//arriva



//derecha



//abajo



















glEnd();

}

//////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////

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

glColor3f(1.0 ,1.0 ,1.0 );

glLineWidth(8);

glBegin(GL_QUADS);

//izquierda



//arriva


//derecha


glEnd();

glColor3f(1.0 ,0.0 ,1.0 );

glLineWidth(8);

glBegin(GL_QUADS);

//cuadro

//izquierda



//arriva


//derecha


//abajo

glEnd();

glColor3f(0.0 ,1.0 ,0.5 );

glLineWidth(8);

glBegin(GL_QUADS);

//cuadro

//izquierda



//arriva


//derecha


//abajo

glEnd();

//cuadro

glColor3f(0.0 ,0.0 ,0.0 );

glLineWidth(4);

glBegin(GL_LINES);

//cuadro

//izquierda



//arriva



//derecha



//abajo



















glEnd();

}

//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////

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

glColor3f(1.0 ,1.0 ,0.0 );

glLineWidth(8);

glBegin(GL_QUADS);

//izquierda



//arriva


//derecha


glEnd();

glColor3f(1.0 ,0.0 ,1.0 );

glLineWidth(8);

glBegin(GL_QUADS);

//cuadro

//izquierda



//arriva


//derecha


//abajo

glEnd();

glColor3f(0.0 ,1.0 ,0.5 );

glLineWidth(8);

glBegin(GL_QUADS);

//cuadro

//izquierda



//arriva


//derecha


//abajo

glEnd();

//cuadro

glColor3f(0.0 ,0.0 ,0.0 );

glLineWidth(4);

glBegin(GL_LINES);

//cuadro

//izquierda



//arriva



//derecha



//abajo



















glEnd();

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

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

glColor3f(1.0 ,1.0 ,1.0 );

glLineWidth(8);

glBegin(GL_QUADS);

//izquierda



//arriva


//derecha


glEnd();

glColor3f(1.0 ,0.0 ,1.0 );

glLineWidth(8);

glBegin(GL_QUADS);

//cuadro

//izquierda



//arriva


//derecha


//abajo

glEnd();

glColor3f(0.0 ,0.0 ,0.0 );

glLineWidth(8);

glBegin(GL_QUADS);

//cuadro

//izquierda



//arriva


//derecha


//abajo

glEnd();

//cuadro

glColor3f(0.0 ,0.0 ,0.0 );

glLineWidth(4);

glBegin(GL_LINES);

//cuadro

//izquierda



//arriva



//derecha



//abajo



















glEnd();

}

/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////


}


{





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

inicializa();




}

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/gl.h>

#include <math.h>

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


{

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

}


{

int angulo=0;

glBegin(GL_TRIANGLE_FAN); glColor3f (2.0, 0.1, 3.0);

glVertex2f(x,y);

glColor3f(0,0.0,0.0);


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 solar
En 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/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;


{



glLoadIdentity();


}

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


glEnd();

}


{

int angulo=0;


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

}


{


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




inicializa();


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

glutMainLoop();

return 0;

}

10. Movimiento en ocho
En 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/gl.h>

#include <math.h>

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

double a=6.15, b=6.15;

void inicializa(void){



glLoadIdentity();


}

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

int angulo=0;


glVertex2f(x,y);


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();

}


{


glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA| GLUT_DEPTH);




inicializa();


glutIdleFunc(dibuja);

glutMainLoop();

return 0;

}

15. Piramide
En esta practica realizamos una pirámide que vista desde arriba se ve en 3D Se
realiza con puras líneas.

CODIGO:

#include <GL/gl.h>

#include <GL/glu.h>


{





}


{int i,a=20;


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();


}


{






inicializa();




}

Manual de actividades

Más contenido relacionado

La actualidad más candente

Similar a Manual de actividades

Manual de actividades