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

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

#include <math.h>

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

glEnd();

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

glEnd();

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

inicializa();

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

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

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

if(y>=1 && y<600 && x==1000){

circulo(1000,700-y,40);

glFlush();

if(w>=1 && w<1000 && y==600 && x==1000){

circulo(1000-w,100,40);

glFlush();

if(z>=1 && z<1000 && y==600 && x==1000 && w==1000){

circulo(5,100+z,40);

glFlush();

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

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

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. PiramideEn 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>

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

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

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

inicializa();

Manual de actividades

Documents

Manual de Actividades Independientes

trajeta de actividades

MANUAL DE INSTRUCCIONES MANUAL DE INSTRUÇÕES INSTRUCTION MANUAL · proveniente del lijado, aserrado, amolado y taladrado eléctrico y otras actividades de construcción. Use vestimenta

Programa de Salud y Bienestar Calendario de Actividades · Programa de Salud y Bienestar Calendario de Actividades Febrero 2019 Actividades sujetas a cambio. Comunícate con Servicios

01 Cuaderno de Actividades

Programa de actividades con profesores de ingles

Manual de Recursos para Nutrición y Actividades Físicastouchbroward.org/.../06/ECE-Manual-SPANISH-web.pdf · Manual de Recursos ... Los Peligros del TV _____ 47 . Guía de Actividad

CATÁLOGO GENERAL DE ACTIVIDADES UNIVERSITARIAS DE. Navales/GENERAL...catÁlogo general de actividades universitarias de • representaciÓn estudiantil • deportivas • culturales

CATÁLOGO GENERAL DE ACTIVIDADES UNIVERSITARIAS DE · catÁlogo general de actividades universitarias de • representaciÓn estudiantil • deportivas • culturales • de cooperaciÓn

Libro de Actividades Minions

Cuadernillo de actividades

CALENDARIO DE ACTIVIDADES

CARTILLA DE ACTIVIDADES - yohamer.wikispaces.comyohamer.wikispaces.com/file/view/RICH-ICFES-ACTIVI-CD EDITED.pdf... · CARTILLA DE ACTIVIDADES. 7 Getting eady for ICFES ACTIVIDADES

ACS, Actividades de Construcción y Servicios, S.A. · ACS, Actividades de Construcción y Servicios, S.A. 3 ACS, ACTIVIDADES DE CONSTRUCCIÓN Y SERVICIOS, S.A. BALANCE SHEETS AT

MANUAL DE ESTRATEGIAS DIDÁCTICAS - UNAMdsp.facmed.unam.mx/.../Manual-de-Estrategias-20016-Chile.pdfy actividades dentro y fuera aula. Este “Manual de Estrategias Didácticas: Orienta-ciones

Icthus - Manual de Actividades Recreativas

Cuaderno de actividades - blm.gov

Actividades de lectoescritura

EMORIA DE ACTIVIDADES 2019

Actividades de los CGS