Proyecto de rene

GRUPO: 303 T/M ESPECIALIDAD:
INFORMATICA

CECYTEMTECÁMAC
UTILIZACIÓN DE DISEÑO PARA
EL MANEJO DE GRÁFICO

ALUMNAS:VERONICA
RODRIGUEZ VICENTE
&
AMANDA MARISOL MARTINEZ
LUNA

PROFESOR:
RENE DOMINGUEZ ESCALONA

INFORMATICA

INTRODUCCIÓN:
OpenGL (Open Graphics Library) es una especificación estándar que define una API multilenguaje
y multiplataforma para escribir aplicaciones que produzcan gráficos 2D y 3D. La interfaz consiste
en más de 250 funciones diferentes que pueden usarse para dibujar escenas tridimensionales
complejas a partir de primitivas geométricas simples, tales como puntos, líneas y triángulos. Fue
2
desarrollada originalmente por Silicón Graphics Inc. (SGI) en 1992 y se usa ampliamente
en CAD, realidad virtual, representación científica, visualización de información y simulación de
vuelo. También se usa en desarrollo de videojuegos, donde compite con Direct3D en
plataformas Windows. OpenGL tiene dos propósitos esenciales:

 Ocultar la complejidad de la interfaz con las diferentes tarjetas gráficas, presentando al
programador una API única y uniforme.
 Ocultar las diferentes capacidades de las diversas plataformas hardware, requiriendo que
todas las implementaciones soporten la funcionalidad completa de OpenGL (utilizando
emulación software si fuese necesario).
El funcionamiento básico de OpenGL consiste en aceptar primitivas tales como puntos, líneas y
polígonos, y convertirlas en píxeles. Este proceso es realizado por una pipeline gráfica conocida
8
comoMáquina de estados de OpenGL. La mayor parte de los comandos de OpenGL bien emiten
primitivas a la pipeline gráfica o bien configuran cómo la pipeline procesa dichas primitivas. Hasta
la aparición de la versión 2.0 cada etapa de la pipeline ejecutaba una función prefijada, resultando
poco configurable. A partir de la versión 2.0 algunas etapas son programables usando un lenguaje
de programación llamadoGLSL.

OpenGL es una API basada en procedimientos de bajo nivel que requiere que el programador dicte
los pasos exactos necesarios para renderizar una escena. Esto contrasta con las APIs descriptivas,
donde un programador sólo debe describir la escena y puede dejar que la biblioteca controle los
detalles para representarla. El diseño de bajo nivel de OpenGL requiere que los programadores
conozcan en profundidad la pipeline gráfica, a cambio de darles libertad para implementar
algoritmos gráficos novedosos.

OpenGL ha influido en el desarrollo de las tarjetas gráficas, promocionando un nivel básico de
funcionalidad que actualmente es común en el hardware comercial; algunas de esas
contribuciones son:

 Primitivas básicas de puntos, líneas y polígonos rasterizados.
 Una pipeline de transformación e iluminación
 Z-buffering.

 Mapeado de texturas.

INFORMATICA
 Alpha blending.

ÍNDICE
 ANIMACIÓN
 CASA
 ESTRELLA
 SISTEMA SOLAR
 MOVIMIENTO EN 8
 CUBO RELLENO
 AJEDREZ
 CUBO CON CUBITOS
 PIRAMIDE
 SEMAFORO
 MUÑECO
 OSO
 SEÑOR TRIANGULOS

INFORMATICA

INFORMATICA

NOMBRE DE LA PRÁCTICA:
“ANIMACIÓN”
PRESENTACIÓN:

INFORMATICA

CÓDIGO:
#include <unistd.h>
#include <GL/glut.h> //arriba
#include <GL/gl.h> if(x==500 && y==500 && a>=1 && a<500){
#include <math.h> circulo (600-1*a,600,40);
int x=1, y=1, a=1, h=1; glFlush();
void inicializa(void) a++;
{ }
glClearColor(1.0,0.6,0.5,0.0);
glMatrixMode(GL_PROJECTION); //izquierda
glLoadIdentity(); if(x==500 && y==500 && a==500 && h>=1
gluOrtho2D(0.0, 800.0, 0.0, 800.0);// el ancho y && h<500){
largo de nuestra pantalla circulo(100,600-1*h,40);
} glFlush();
h++;
void circulo(int x, int y, int radio) }
{ //Reptir
int angulo=0; if(h==500){
glBegin(GL_TRIANGLE_FAN); x=1;
glColor3f (1.0, 0.3, 0.5); y=1;
glVertex2f(x,y); a=1;
glColor3f(0,0.0,0.0); h=1;
for (angulo=0;angulo<=360; }
angulo+=6){ glVertex2f(x + sin(angulo) * radio, y
+ cos(angulo) * radio);}
glEnd(); glutSwapBuffers();
} }
void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT | int main (int argc, char** argv)
GL_DEPTH_BUFFER_BIT); {
//abajo glutInit(&argc, argv);
if(x>=1 && x<500){ glutInitDisplayMode(GLUT_DOUBLE |
circulo(100+1*x,100,40); GLUT_RGBA| GLUT_DEPTH);
glFlush(); glutInitWindowSize(800,800);
x++; glutInitWindowPosition(10,10);
} glutCreateWindow("Ventana");
inicializa();
//derecha glutDisplayFunc(dibuja);
if(x==500 && y>=1 && y<500){ glutIdleFunc(dibuja);
circulo (600,100+1*y,40); glutMainLoop();
glFlush(); return 0;
y++; }
}

INFORMATICA

“CASA”
CÓDIGO:
//Los puntos en toda la pantalla glVertex2i(0,289);
#include <GL/glut.h> glVertex2i(1000,289);
#include <GL/gl.h> glVertex2i(1000,280);
glVertex2i(0,280);
void inicializa(void)
{ //pasto
glClearColor (3.0, 1.0, 1.0, 1.0); glColor3f (0.3, 0.5, 0.2);
glMatrixMode(GL_PROJECTION); glVertex2i(0,240);
glLoadIdentity(); glVertex2i(1000,240);
gluOrtho2D(0.0,1000.0,0.0,600.0); glVertex2i(1000,120);
} glVertex2i(0,120);
//banqueta
void dibuja(void) glColor3f (0.5, 0.5, 0.5);
{ glVertex2i(0,120);
int i,j=0; glVertex2i(1000,120);
glVertex2i(1000,90);
/* borra la pantalla */ glVertex2i(0,90);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 0.0, 0.0);
// Cerca glVertex2i(0,90);
for(i=0;i<50;i++){ glVertex2i(1000,90);
glBegin(GL_POLYGON); glVertex2i(1000,82);
glColor3f (2.0, 0.3, 1.0); glVertex2i(0,82);
glVertex2f(0+20*i,292); //calle
glVertex2f(5+20*i,300); glColor3f (0.3, 0.3, 0.3);
glVertex2f(10+20*i,292); glVertex2i(0,82);
glEnd(); glVertex2i(0,0);
}
glBegin(GL_QUADS); //piedras
glColor3f (0.3, 0.6, 0.6);

INFORMATICA
glVertex2i(105,180); glColor3f (0.3, 0.5, 0.9);
glVertex2i(135,180); glVertex2i(90,315);
glVertex2i(90,195);
glVertex2i(195,180); //Puerta
//Columnas
//entrada glVertex2i(75,195);
// Casa
glColor3f (0.5, 0.0, 0.7);
// Techo casa
glColor3f (0.3, 0.5, 0.3); glVertex2i(405,435);
// Techo cochera //Ventanas i
//Cortina glVertex2i(240,375);

INFORMATICA
glBegin(GL_TRIANGLES);
glVertex2i(240,300); // Techo balcon
//Ventanas d glEnd();
glVertex2i(450,435); //arboles
glVertex2i(510,435); glLineWidth (4);
glVertex2i(510,375); glBegin(GL_LINES);
for(i=0;i<32;i++){
glVertex2i(450,300); glVertex2i(680-3*i,540-10*j);
glVertex2i(510,300); glVertex2i(690+3*i,540-10*j);
//Ventanas balcon
j=j+1;
//Ventanas puerta }
glVertex2i(360,285); glEnd();
glVertex2i(390,210); //Linea Calle
glVertex2i(360,210); glLineWidth (4);
glColor3f (0.0, 0.0, 0.0);
//Tallos glBegin(GL_LINES);
glColor3f (0.5, 1.0, 0.5);
glVertex2i(670,225); for(i=0;i<50;i++){
glVertex2i(700,225); glVertex2i(0+120*i,41);
glVertex2i(700,150); glVertex2i(90+120*i,41);
glVertex2i(670,150); }

glVertex2i(875,225); //Barandal
glVertex2i(875,150); for(i=0;i<7;i++){
glVertex2i(345+10*i,375);
glVertex2i(345+10*i,330);
glEnd(); }
//Divicion Ventana

INFORMATICA
glVertex2i(510,397); glBegin(GL_LINE_LOOP);
glVertex2i(270,262); //Chapa
glVertex2i(270,240); glPointSize(4);
glColor3f (0.5, 1.0, 0.5);
glVertex2i(480,397); glBegin(GL_POINTS);

glEnd(); glFlush();
}

//Contorno ventanas int main(int argc, char** argv)
glBegin(GL_LINE_LOOP); {
glVertex2i(240,435); glutInit(&argc, argv);
glVertex2i(300,435); glutInitDisplayMode(GLUT_SINGLE |
glVertex2i(300,375); GLUT_RGBA);
glVertex2i(240,375); glutInitWindowSize(1000,600);
glEnd(); glutInitWindowPosition(100,100);
glBegin(GL_LINE_LOOP); glutCreateWindow("My Home");
glVertex2i(240,300); inicializa();
glVertex2i(300,300); glutDisplayFunc(dibuja);
glVertex2i(300,240); glutMainLoop();
glVertex2i(240,240); return 0;
glEnd(); }
glBegin(GL_LINE_LOOP);

INFORMATICA

“ESTRELLA”
PRESENTACIÓN:

INFORMATICA

CODIGO:
//mi primer ventana
#include <GL/glut.h> glBegin(GL_LINES);
#include <GL/glu.h> glVertex2i(300,100);

void inicializa(void) glBegin(GL_LINES);
glClearColor(1.0,0.8,1.0,0.0); //color de glVertex2i(100,100);
fondo
glMatrixMode(GL_PROJECTION); glEnd();
//Modo de proyeccion glFlush(); //forza dibujo
glLoadIdentity(); //Establece los }
parametros de proyeccion
gluOrtho2D(0.0, 1000.0, 0.0, 1000.0);
//vista ortogonal int main (int argc, char** argv) //metodo
} main
{
void dibuja(void) //funcion glutInit(&argc, argv);
dibuja //incializa GLUT
{ glutInitDisplayMode(GLUT_SINGLE |
GLUT_RGBA); //establece el modo de
glClear(GL_COLOR_BUFFER_BIT); visualización
glColor3f(0.0 ,0.0 ,0.0 ); glutInitWindowSize(475,475);
glPointSize(50); //tamaño de la ventana
glutInitWindowPosition(0,0);
glBegin(GL_LINES); //posicion inicial de la ventana
glVertex2i(350,300); glutCreateWindow("ESTRELLA");
glVertex2i(100,300); //nombre de la ventana
inicializa();
glBegin(GL_LINES);
glVertex2i(300,100); glutDisplayFunc(dibuja); //Envia
glVertex2i(200,400); los graficos a la ventana de visualización
glutMainLoop(); //muestra
glBegin(GL_LINES); todo y espera
glVertex2i(200,400); return 0;

INFORMATICA

“SISTEMA SOLAR”
PRESENTACIÓN:

INFORMATICA

CÓDIGO:
#include <unistd.h> {
#include <GL/glut.h> glClear(GL_COLOR_BUFFER_BIT |
#include <GL/gl.h> GL_DEPTH_BUFFER_BIT);//esto
#include <math.h> glColor3f (1.0, 1.0, 0.0);
int rad=100; circulo( 500,500,30); //funcion circulo
double ang=0, a=0, l=0, d=0, o=0, t=0, e=0, //funcion circulo
q=0, m=0; circuloc (500,500,1,50);
void inicializa(void) glColor3f (1.5, 0.8, 0.7);
{ circulo( 500+ sin(a) * 50,500 - cos(a) * 50,10);
glClearColor(0.3,0.0,0.0,0.0); circuloc (500,500,1,50);
glMatrixMode(GL_PROJECTION); glColor3f (1.0, 0.0, 0.6);
glLoadIdentity(); circulo( 500+ sin(l) * 100,500 + cos(l) *
gluOrtho2D(0.0, 1000.0, 0.0, 1000.0);// el 100,20);
ancho y largo de nuestra pantalla circuloc (500,500,1,100);
} glColor3f (0.6, 0.4, 0.5);
circulo( 500+ sin(d) * 150,500 - cos(d) *
void circulo(int x, int y, int radio) 150,15);
{ circuloc (500,500,1,150);
int angulo=0; glColor3f (0.8, 1.0, 0.5);
glBegin(GL_TRIANGLE_FAN); circulo( 500+ sin(o) * 200,500 + cos(o) *
for (angulo=0;angulo<=360; 200,30);
angulo++){ glVertex2f(x + sin(angulo) * radio, circuloc (500,500,1,200);
y + cos(angulo) * radio);} glColor3f (0.5, 0.5, 0.5);
glEnd(); circulo( 500+ sin(t) * 250,500 - cos(t) *
} 250,25);
void circuloc(int x, int y, int t, int radio) circuloc (500,500,1,250);
{ glColor3f (1.0, 0.3, 0.7);
int angulo=0; circulo( 500+ sin(e) * 300,500 + cos(e) *
glPointSize(t); 300,30);
glBegin(GL_POINTS); circuloc (500,500,1,300);
//glColor3f (0.4, 0.3, 0.6); glColor3f (0.5, 0.2, 1.0);
glVertex2f(x,y); circulo( 500+ sin(q) * 350,500 - cos(q) *
//glColor3f(0,0.0,0.0); 350,20);
for (angulo=0;angulo<=360; circuloc (500,500,1,350);
angulo+=1){ glVertex2f(x + sin(angulo) * glColor3f (0.5, 1.0, 0.8);
radio, y + cos(angulo) * radio);} circulo( 500+ sin(m) * 400,500 + cos(m) *
glEnd(); 400,15);
} circuloc (500,500,1,400);
void dibuja(void) glColor3f (0.0, 0.0, 1.0);

INFORMATICA
circulo( 500+ sin(ang) * 450,500 + cos(ang) * glutSwapBuffers(); //y esto
450,30); }
circuloc (500,500,1,450);
glColor3f (0.0, 0.0, 1.0);
a=a+0.02; int main (int argc, char** argv)
l=l+0.03; {
d=d+0.04; glutInit(&argc, argv);
o=o+0.05; glutInitDisplayMode(GLUT_DOUBLE |
t=t+0.06; GLUT_RGBA| GLUT_DEPTH);//esto tambien
e=t+0.07; glutInitWindowSize(1000,1000);
q=q+0.08; glutInitWindowPosition(10,10);
m=m+0.09; glutCreateWindow("Ventana");
ang=ang+0.01; //velocidad entre mas grande inicializa();
mas rapido y entre menos mas lento glutDisplayFunc(dibuja);
for(int j=1;j<=10000000;j++){}//pausa glutIdleFunc(dibuja);//esto es lo que cambia
if(ang==360){ang=0;}// se repite glutMainLoop();
idefinidamente return 0;
glFlush(); //forzar dibujado }

INFORMATICA

“MOVIMIENTO EN 8”
PRESENTACIÓN:

INFORMATICA

CODIGO:
#include <unistd.h> int x=1, x2=1,y=1;
#include <GL/glut.h> double a=6.15, b=6.15;
#include <GL/gl.h> void inicializa(void){
#include <math.h> glClearColor(0.5,0.6,1.0,0.9);

INFORMATICA
glMatrixMode(GL_PROJECTION); if(a>=6.15 && a<=12.41){
glLoadIdentity(); circulo(300+ sin (a)*60,300- cos(a)*60,10);
gluOrtho2D(0.0, 700.0, 0.0, 700.0);// el a=a+0.02;
ancho y largo de nuestra pantalla }
} else{
circulo(300 + sin (b) *60,180-cos(b)*-60,10);
void circulo(int x, int y, int radio){ b=b + 0.2;
int angulo=0; if(b>12.4){a=6.15;b=6.15;}
glBegin(GL_TRIANGLE_FAN); for(int j=0; j<=10000000; j++) {}
glVertex2f(x,y); }
for (angulo=0;angulo<=360;
angulo+=6){ glVertex2f(x + sin(angulo) * glFlush();
radio, y + cos(angulo) * radio);} glutSwapBuffers();
glEnd();} }
void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT | int main (int argc, char** argv)
GL_DEPTH_BUFFER_BIT); {
glColor3f(0.5, 0.0, 1.0); glutInit(&argc, argv);
circulo(300, 300, 70); glutInitDisplayMode(GLUT_DOUBLE |
GLUT_RGBA| GLUT_DEPTH);
circulo(300,180,70); glutInitWindowSize(700,700);
glColor3f(1.0, 0.0, 0.8); glutInitWindowPosition(10,10);
glutCreateWindow("Ventana");
circulo(300,300,50); inicializa();
glutDisplayFunc(dibuja);
circulo(300,180,50); glutIdleFunc(dibuja);
glutMainLoop();
glColor3f(1.0,0.9,2.0); return 0;
}

INFORMATICA

“CUBO RELLENO”
PRESENTACIÓN:

INFORMATICA

CÓDIGO:
//mi primer ventana glLineWidth(l);
#include <GL/gl.h> glVertex2f(x,y);
void inicializa(void) glVertex2f(x+t,y);
{ glVertex2f(x+t,y);
glClearColor(1.0,1.0,1.0,0.0); //color de glVertex2f(x+t,y+t);
fondo glVertex2f(x+t,y+t);
glMatrixMode(GL_PROJECTION); glVertex2f(x,y+t);
//Modo de proyeccion glVertex2f(x,y);
glLoadIdentity(); //Establece los
gluOrtho2D(0.0, 500.0, 0.0, 500.0); //vista glVertex2f(x,y+t);
ortogonal glVertex2f(x+t,y+t);
} glVertex2f(x+t,y+t);
glVertex2f(x+t+(t*a),y+t+(t*b));
void cubo (int x, int y,int t,int l){ glVertex2f(x+t+(t*a),y+t+(t*b));
double a=.8,b=.6; glVertex2f(x+(t*a),y+t+(t*b));
glColor3f(1.0 , 1.0 , 0.0); glVertex2f(x,y+t);
glBegin(GL_QUADS); glVertex2f(x+t+(t*a),y+t+(t*b));
glVertex2f(x,y); glVertex2f(x+(t*a),y+t+(t*b));
glVertex2f(x+t,y);
glVertex2f(x+t,y+t); glVertex2f(x+t,y+t);
glVertex2f(x,y+t); glVertex2f(x+t+(t*a),y+t+(t*b));
glColor3f(1.0 , 0.0 , 1.0); glVertex2f(x+t+(t*a),y+t+(t*b));
glVertex2f(x,y+t); glVertex2f(x+t+(t*a),y+(t*b));
glVertex2f(x+t,y+t); glVertex2f(x+t+(t*a),y+(t*b));
glVertex2f(x+t+(t*a),y+t+(t*b)); glVertex2f(x+t,y);
glVertex2f(x+(t*a),y+t+(t*b)); glVertex2f(x+t,y+t);
glColor3f(1.0 , 0.0 , 0.0); glEnd();
glVertex2f(x+t,y+t); }
glVertex2f(x+t+(t*a),y+t+(t*b));
glVertex2f(x+t+(t*a),y+(t*b));
glVertex2f(x+t,y); void dibuja(void) //funcion
glEnd(); dibuja
{
glColor3f(0.0 , 0.0 , 0.0);

INFORMATICA
glClear(GL_COLOR_BUFFER_BIT); }
//borra pantalla
glColor3f(1.0 , 0.0 , 0.0);
//diagonal derecha
for(int i=0;i<=5;i++){
// cubo de atras //lineas derechas
cubo(405-16*i,185-16*i,20,5);
for(int i=0;i<=10;i++){ }
//linea derecha, izquierda
cubo(200,200+20*i,20,5); ///////////////////////////////////////////////
} //////////////////////////////////
for(int j=0;j<=9;j++){ // cubo de adelante
//lineas acostadas for(int i=0;i<=10;i++){
//linea acostada, abajo //lineas derechas
cubo(220+20*j,200,20,4); cubo(100,100+20*i,20,5);
//linea acostada,
cubo(220+20*j,400,20,5); }
//linea derecha, derecha for(int j=0;j<=9;j++){
//lineas acostadas
} cubo(120+20*j,100,20,4);
for(int i=0;i<=10;i++){ //d
cubo(420,200+20*i,20,5); cubo(120+20*j,300,20,5);
} //diagonales
//diagonales
//diagonal izquierda }
for(int i=0;i<=5;i++){ for(int i=0;i<=10;i++){
//lineas derechas cubo(320,100+20*i,20,5);
cubo(185-16*i,185-16*i,20,5); }
}
//diagonal derecha glFlush(); //forza dibujo
for(int i=0;i<=5;i++){ }
//lineas derechas
cubo(185-16*i,185-16*i,20,5); int main (int argc, char** argv) //metodo
} main
//diagonal derecha {
for(int i=0;i<=5;i++){ glutInit(&argc, argv);
//lineas derechas //incializa GLUT
cubo(405-16*i,387-16*i,20,5); glutInitDisplayMode(GLUT_SINGLE |
} GLUT_RGBA); //establece el modo de
//diagonal derecha visualización
for(int i=0;i<=5;i++){ glutInitWindowSize(500,500);
//lineas derechas //tamaño de la ventana
cubo(185-16*i,387-16*i,20,5);

INFORMATICA
glutInitWindowPosition(100,100); glutDisplayFunc(dibuja); //Envia
//posicion inicial de la ventana los graficos a la ventana de visualización
glutCreateWindow("Ventana"); glutMainLoop(); //muestra
//nombre de la ventana todo y espera
inicializa(); return 0; //retorna un
valor de cero

“AJEDREZ”
PRESENTACIÓN:

INFORMATICA

CÓDIGO:

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

INFORMATICA
void inicializa(void) glVertex2i(800,600);
fondo glVertex2i(300,700);
//Modo de proyeccion glVertex2i(500,700);
glLoadIdentity(); //Establece los glVertex2i(600,800);
parametros de proyeccion glVertex2i(700,700);
gluOrtho2D(0.0, 1000.0, 0.0, 1000.0); glVertex2i(800,800);
//vista ortogonal glEnd();
} glColor3f(0.0 ,0.0 ,0.0 );
glPointSize(50);
void dibuja(void) //funcion glBegin(GL_POINTS);
dibuja glVertex2i(200,100);
glClear(GL_COLOR_BUFFER_BIT); glVertex2i(500,200);
glColor3f(1.0 ,1.0 ,1.0 ); glVertex2i(600,100);
glPointSize(50); glVertex2i(700,200);
glBegin(GL_POINTS); glVertex2i(800,100);

INFORMATICA
glVertex2i(800,700); GLUT_RGBA); //establece el modo de
glVertex2i(100,800); visualización
glutInitWindowSize(475,475);
glEnd(); //tamaño de la ventana
glColor3f(1.0 ,1.0 ,1.0 ); glutInitWindowPosition(0,0);
glPointSize(50); //posicion inicial de la ventana
glBegin(GL_LINE); glutCreateWindow("ajedrez");
glEnd();
glFlush(); //forza dibujo glutDisplayFunc(dibuja); //Envia
} los graficos a la ventana de visualización
glutMainLoop(); //muestra
todo y espera
int main (int argc, char** argv) //metodo return 0; //retorna un
main valor de cero
{ }
glutInit(&argc, argv);
//incializa GLUT

INFORMATICA

“CUBO CON CUBITOS”
PRESENTACIÓN:

INFORMATICA
glutInitWindowPosition(100,100); glutMainLoop(); //muestra
//posicion inicial de la ventana todo y espera
glutCreateWindow("Ventana"); return 0; //retorna un
//nombre de la ventana valor de cero
inicializa(); }
glutDisplayFunc(dibuja); //Envia
los graficos a la ventana de visualización

“PIRAMIDE”
PRESENTACIÓN:

INFORMATICA

CÓDIGO:
//mi primer ventana

void inicializa(void) glBegin(GL_LINES);
fondo
glMatrixMode(GL_PROJECTION); glBegin(GL_LINES);
//Modo de proyeccion glVertex2i(600,400);
gluOrtho2D(0.0, 1050.0, 0.0, 1000.0);
//vista ortogonal }
glEnd();
} glFlush(); //forza dibujo

void dibuja(void) //funcion
dibuja }
{ int main (int argc, char** argv) //metodo
int i,a=20; main
glClear(GL_COLOR_BUFFER_BIT); {
glColor3f(1.0 ,1.0 ,1.0 ); glutInit(&argc, argv);
glLineWidth(4); //incializa GLUT
glBegin(GL_LINES); glutInitDisplayMode(GLUT_SINGLE |
for(i=0;i<=12;i++){ GLUT_RGBA); //establece el modo de
glVertex2i(400-a*i,400-a*i); visualización
glVertex2i(600+a*i,400-a*i); glutInitWindowSize(450,450);
glVertex2i(600+a*i,400-a*i); //tamaño de la ventana
glVertex2i(600+a*i,600+a*i); glutInitWindowPosition(0,0);
glVertex2i(600+a*i,600+a*i); //posicion inicial de la ventana
glVertex2i(400-a*i,600+a*i); glutCreateWindow("piramide");
glVertex2i(400-a*i,600+a*i); //nombre de la ventana
glVertex2i(400-a*i,400-a*i); inicializa();
//diagonales
glBegin(GL_LINES); glutDisplayFunc(dibuja); //Envia
glVertex2i(400,400); los graficos a la ventana de visualización

INFORMATICA
glutMainLoop(); //muestra return 0; //retorna un
todo y espera valor de cero
}

“SEMAFORO”
CODIGO:
//mi primer ventana void circulo(int x, int y, int radio)
#include <GL/glut.h> {
#include <GL/gl.h> int angulo=0;
#include <math.h> glBegin(GL_TRIANGLE_FAN);
void inicializa(void) // glColor3f (1.0, 0.0, 1.0);
{ glVertex2f(x,y);
glClearColor(1.0,1.0,1.0,0.0); //color de
fondo for (angulo=0;angulo<=360;
glMatrixMode(GL_PROJECTION); angulo+=1){ glVertex2f(x + sin(angulo) *
//Modo de proyeccion radio, y + cos(angulo) * radio);}
glLoadIdentity(); //Establece los glEnd();
parametros de proyeccion }
gluOrtho2D(0.0, 500.0, 0.0, 500.0); //vista
ortogonal void dibuja(void) //funcion
} dibuja
void circuloc(int x, int y, int t, int radio) {
{ glClear(GL_COLOR_BUFFER_BIT);
int angulo=0; glColor3f(0.0,1.0,0.0); //borra pantalla
glPointSize(t);
glBegin(GL_POINTS); circuloc(250,250,5,80);
//glColor3f (1.0, 0.0, 1.0); glFlush(); //forza dibujo
glVertex2f(x,y); }
//glColor3f(0,0.0,0.0);
for (angulo=0;angulo<=360;
angulo+=1){ glVertex2f(x + sin(angulo) * int main (int argc, char** argv) //metodo
radio, y + cos(angulo) * radio);} main
glEnd(); {
} glutInit(&argc, argv);
//incializa GLUT

INFORMATICA
glutInitDisplayMode(GLUT_SINGLE | glutCreateWindow("Ventana");
GLUT_RGBA); //establece el modo de //nombre de la ventana
visualización inicializa();
glutInitWindowSize(500,500); glutDisplayFunc(dibuja); //Envia
//tamaño de la ventana los graficos a la ventana de visualización
glutInitWindowPosition(100,100); glutMainLoop(); //muestra
//posicion inicial de la ventana todo y espera
return 0; //retorna
un valor de cero

}

INFORMATICA

“MUÑECO”
PRESENTACIÓN:

INFORMATICA

CÓDIGO:
//mi primer ventana
#include <GL/glut.h> for (angulo=0;angulo<=360;
#include <GL/gl.h> angulo+=1){ glVertex2f(x + sin(angulo) *
#include <GL/glu.h> radio, y + cos(angulo) * radio);}
#include <math.h>
void inicializa(void)
{ }
glClearColor(0.5,0.3,1.0,0.0); //color de void dibuja(void) //funcion
fondo dibuja
glMatrixMode(GL_PROJECTION); {
//Modo de proyeccion glClear(GL_COLOR_BUFFER_BIT);
glLoadIdentity(); //Establece los //borra pantalla
parametros de proyeccion // pie izquierdo
gluOrtho2D(0.0, 1000.0, 0.0, 1000.0); glBegin(GL_QUADS);
//vista ortogonal glColor3f(0.0,0.0,0.0);
void circuloc(int x, int y, int t, int radio) glVertex2i(300,100);
int angulo=0; glVertex2i(250,150);
glPointSize(t); // pie derecho
glBegin(GL_POINTS); glColor3f(0.0,0.0,0.0);
//glColor3f (1.0, 0.0, 1.0); glVertex2i(450,100);
glVertex2f(x,y); glVertex2i(450,150);
//glColor3f(0,0.0,0.0); glVertex2i(500,150);
for (angulo=0;angulo<=360; glVertex2i(550,100);
angulo+=1){ glVertex2f(x + sin(angulo) * // pantalon
radio, y + cos(angulo) * radio);} glColor3f(1.0,1.,1.0);
void circulo(int x, int y, int radio) glVertex2i(475,250);
{
int angulo=0; glColor3f(1.0,1.0,1.0);
glBegin(GL_TRIANGLE_FAN); glVertex2i(250,150);
// glColor3f (1.0, 0.0, 1.0); glVertex2i(275,250);
glVertex2f(x,y); glVertex2i(375,250);

INFORMATICA
glColor3f(1.0,1.0,1.0); glVertex2i(220,375);
glVertex2i(375,250); // mano derecha
// cinturon glVertex2i(530,375);
glColor3f(0.0,1.0,0.0); // botones de la camisa
glVertex2i(300,325); glColor3f(0.5,0.2,0.0);
glColor3f(1.0,0.0,0.0);
// camisa
// camisa torax glVertex2i(350,375);
glVertex2i(525,550); // cuello
// manga izquierda glColor3f(0.9,0.8,0.7);
// manga derecha glEnd();
glVertex2i(450,550); glBegin(GL_TRIANGLES);
// mano izquierda glVertex2i(400,600);
glVertex2i(200,375); // cabeza circulo

INFORMATICA
circulo(375,750,150); glVertex2i(375,950);

//ojos glVertex2i(510,820);
glBegin(GL_QUADS);
glColor3f(0.2,0.5,1.0);
glVertex2i(300,750); //manos en circulo
glVertex2i(350,800); glBegin(GL_POLYGON);
glColor3f(0.2,0.5,1.0); circulo(520,375,20);
glVertex2i(400,800); circulo(210,375,20);
glEnd();
//ojos centro
// cabeza circulo glEnd();
glColor3f(0.0,0.0,0.0); glFlush(); //forza dibujo
circulo(340,780,10); }
glEnd();
glColor3f(0.0,0.0,0.0);
circulo(440,780,10); int main (int argc, char** argv) //metodo
glEnd(); main
//narizz {
glBegin(GL_POLYGON); glutInit(&argc, argv);
glColor3f(1.0,0.3,0.5); //incializa GLUT
glVertex2i(400,725); visualización
glEnd(); glutInitWindowSize(900,800);
//boca //tamaño de la ventana
glLineWidth(5); glutInitWindowPosition(0,0);
glBegin(GL_LINES); //posicion inicial de la ventana
glColor3f(1.0,0.3,0.2); glutCreateWindow("MI primer ventana");
glEnd(); glutDisplayFunc(dibuja); //Envia
//cabello los graficos a la ventana de visualización
glBegin(GL_TRIANGLES); glutMainLoop(); //muestra
glColor3f(0.8,0.5,0.2); todo y espera

INFORMATICA
return 0; //retorna un }
valor de cero

INFORMATICA

“OSO”
PRESENTACIÓN:

INFORMATICA

CÓDIGO:
//mi primer ventana for (angulo=0;angulo<=360;
#include <GL/glut.h> angulo+=1){ glVertex2f(x + sin(angulo) *
#include <GL/gl.h> radio, y + cos(angulo) * radio);}
#include <math.h> glEnd();
void inicializa(void) }
{
glClearColor(1.0,1.0,1.0,0.0); //color de void dibuja(void) //funcion
fondo dibuja
glMatrixMode(GL_PROJECTION); {
//Modo de proyeccion glClear(GL_COLOR_BUFFER_BIT);
glLoadIdentity(); //Establece los glColor3f(0.6,0.4,0.2); //borra pantalla
parametros de proyeccion circulo(200,200,150);
gluOrtho2D(0.0, 500.0, 0.0, 500.0); //vista glColor3f(0.6,0.4,0.2);
ortogonal //
} circulo(300,300,50);
void circuloc(int x, int y, int t, int radio) glColor3f(0.6,0.4,0.2);
{ //
int angulo=0; circulo(100,300,50);
glPointSize(t); glColor3f(0.6,0.4,0.2);
glBegin(GL_POINTS); //
//glColor3f (1.0, 0.0, 1.0); circulo(100,100,50);
glVertex2f(x,y); glColor3f(0.6,0.4,0.2);
//glColor3f(0,0.0,0.0); //
for (angulo=0;angulo<=360; circulo(300,100,50);
angulo+=1){ glVertex2f(x + sin(angulo) * glColor3f(0.6,0.4,0.2);
radio, y + cos(angulo) * radio);} //
glEnd(); circulo(200,400,90);
} glColor3f(0.6,0.4,0.2);
//boca
void circulo(int x, int y, int radio) circulo(200,400,10);
{ glColor3f(1.0,0.0,0.0);
int angulo=0; //
glBegin(GL_TRIANGLE_FAN); circulo(200,350,30);
// glColor3f (1.0, 0.0, 1.0); glColor3f(0.6,0.4,0.2);
glVertex2f(x,y); //
circulo(259,480,30);

INFORMATICA
glColor3f(0.6,0.4,0.2);
// glFlush(); //forza dibujo
circulo(150,480,30); }
glColor3f(0.6,0.4,0.2);

//ojos blancos int main (int argc, char** argv) //metodo
circulo(150,425,25); main
glColor3f(0.0,0.0,0.0); {
circulo(250,425,25); glutInit(&argc, argv);
glColor3f(0.0,0.0,0.0); //incializa GLUT
circulo(150,425,25); glutInitDisplayMode(GLUT_SINGLE |
glColor3f(0.0,0.0,0.0); GLUT_RGBA); //establece el modo de
circulo(150,425,25); visualización
glColor3f(0.0,0.0,0.0); glutInitWindowSize(500,500);
//tamaño de la ventana
//ojos negros glutInitWindowPosition(100,100);
circulo(150,425,10); //posicion inicial de la ventana
glColor3f(1.0,1.0,1.0); glutCreateWindow("ositha");
circulo(250,425,10); //nombre de la ventana
glColor3f(1.0,1.0,1.0); inicializa();
circulo(150,425,10); glutDisplayFunc(dibuja); //Envia
glColor3f(1.0,1.0,1.0); los graficos a la ventana de visualización
circulo(150,425,10); glutMainLoop(); //muestra
glColor3f(1.0,1.0,1.0); todo y espera
return 0; //retorna un
//ombligo valor de cero
circulo(200,170,10); }
glColor3f(0.6,0.5,0.2);

INFORMATICA

“SEÑOR TRIANGULOS”
PRESENTACIÓN:

INFORMATICA

CÓDIGO:
//mi primer ventana glColor3f(1.0 , 1.0 , 1.0);
#include <GL/glut.h> glVertex2i(245,360);
#include <GL/gl.h> glColor3f(1.0 , 0.9 , 0.0);
glEnd();
void inicializa(void) //pierna izquierda
{
glClearColor(0.0,1.0,1.0,0.0); //color de glColor3f(1.0 , 0.6 , 0.0);
fondo glBegin(GL_TRIANGLES);
//Modo de proyeccion glColor3f(1.8,0.6,1.0);
parametros de proyeccion glColor3f(0.2 ,1.0,0.7);
gluOrtho2D(0.0, 1000.0, 0.0, 1000.0); glVertex2i(420,280);
//vista ortogonal glEnd();
}
//pata izquierda
void dibuja(void) //funcion glColor3f(1.0 , 1.0 , 0.6);
dibuja glBegin(GL_TRIANGLES);
glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0 , 0.0 , 0.0);
//borra pantalla glVertex2i(380,240);
glColor3f(1.0 , 0.0 , 0.0); glColor3f(0.5 , 1.0 , 0.0);
///pata derecha glVertex2i(420,180);
glBegin(GL_TRIANGLES); glEnd();
glVertex2i(160,40); //pata sobre el balon
glVertex2i(245,40); glBegin(GL_TRIANGLES);
glColor3f(1.0 , 1.0 , 0.0); glVertex2i(420,180);
glVertex2i(200,80); glColor3f(0.0 , 0.0 , 1.0);
//pata de arriba derecha glColor3f(0.0 ,0.0 , 1.0);
glColor3f(1.0 , 1.0 , 0.9); glEnd();
glVertex2i(245,40); //mano dercha(dedos)

INFORMATICA
glColor3f(1.0 , 0.9 , 1.0); glBegin(GL_TRIANGLES);
glBegin(GL_TRIANGLES); glVertex2i(480,400);
glEnd();
glColor3f(1.0 , 0.5 , 0.7);
glColor3f(1.0 , 1.0 , 0.5);
glEnd(); glColor3f(1.0 , 0.2 , 0.8);
glColor3f(1.0 , 1.0 , 0.6);
glEnd(); glColor3f(1.0 , 0.7 , 0.7);
glColor3f(1.0 , 1.0 , 0.1);
glEnd(); glColor3f(1.0 , 0.7 , 0.5);
glColor3f(1.0 , 0.4 , 1.2);

INFORMATICA
glVertex2i(440,60);
glColor3f(1.0 , 0.8 , 1.0);
glVertex2i(1440,0);
glColor3f(1.0 , 1.0 , 0.0);
glColor3f(1.0 , 1.0 , 1.0);
glColor3f(1.0 , 0.0 , 0.0); glFlush(); //forza dibujo
glEnd();
//camiza int main (int argc, char** argv) //metodo
glBegin(GL_QUADS); main
glColor3f(0.6 , 0.5 , 0.4); {
glVertex2i(200,520); glutInit(&argc, argv);
glVertex2i(200,340); //incializa GLUT
glEnd(); visualización
glutInitWindowSize(500,500);
glColor3f(1.0 , 0.5 , 0.0); //tamaño de la ventana
glBegin(GL_TRIANGLES); glutInitWindowPosition(0,0);
glVertex2i(260,520); //posicion inicial de la ventana
glColor3f(1.0 , 1.0 , 1.0); glutCreateWindow("MI primer ventana");
glColor3f(1.0 , 1.0 , 0.9); inicializa();
glVertex2i(320,520); glutDisplayFunc(dibuja); //Envia
glEnd(); los graficos a la ventana de visualización
//balon glutMainLoop(); //muestra
glBegin(GL_POLYGON); todo y espera
glVertex2i(520,100); return 0; //retorna un
glVertex2i(520,140); valor de cero

Proyecto de rene

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (13)

Destaque

Destaque (20)

Semelhante a Proyecto de rene

Semelhante a Proyecto de rene (20)

Mais de La Qrazii Luniitha

Mais de La Qrazii Luniitha (7)

Último

Último (20)

Proyecto de rene