Proyecto de reneya terminado

CECYTEM PLANTEL TECAMAC

(Colegio de Estudios Científicos y Tecnológicos del Estado de México)

Integrantes:

Ana Karen Avila Enciso

Jesica González Aguilar

Grupo: 303

N.L. 1 N.L. 14

Materia:

Utilización de Software de Diseño

Especialidad: Técnico en Informática.

Profesor: René Domínguez Escalona

Manual de Practicas del Segundo Parcial

INTRODUCCION.

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 y3D. 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
desarrollada originalmente por Silicón Graphics Inc. (SGI) en 19922 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 Microsoft 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 como Máquina de estados de OpenGL.8 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 llamado GLSL.

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.

Tablero de Ajedrez

Presentación o descripción:

En esta práctica realizaremos una tablero de Ajedrez con puntos esta solo para
empezar a poner en práctica la utilización de este programa.

Esta es la practica numero 1 y con esta empezamos a ver si es posible entenderle
a este programa.

Los cuadros deben de ir de color blanco y negro y este es el código para su
realización.

GlBegin (GL_POINTS);

Y

glPointSize(60); (Para definer el tamaño de los puntos)

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

}

Estrella


En esta práctica realizaremos una estrella como con puras líneas.

Esta es la practica numero 2 y con esta empezamos utilizaremos solamente líneas
que es la siguiente instrucción:

glBegin(GL_LINES);

Codigo:

//mi primer ventana


#include <GL/gl.h>

#include <GL/glu.h>


{





}


{


glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_LINES);











glEnd();


}


{


visualización




inicializa();

visualización



}

Y asi es como queda:

Cubo con Líneas


En esta práctica realizamos un cubo con puras líneas asiendo el efecto para que
se vea como en 3D pero aun no se vera asi.

Esta es la practica numero 3 y en esta aprenderemos a utilizar aun mas y poner
en practica las líneas.

En esta práctica podemos utilizar las siguientes instrucciones que ya hemos
aprendido como se utilizan en todas las clases anteriores:

glBegin(GL_LINES);

Codigo:

//TABLERO DE AJEDREZ


#include <GL/gl.h>

#include <GL/glu.h>


{





}


{

glClear(GL_COLOR_BUFFER_BIT);

glColor3f(1.0 ,0.0 ,1.0 );

glBegin(GL_LINES);

























glEnd();


}


{


visualización




inicializa();

visualización



}

Asi es como queda:

Cubo delineado


En esta práctica realizamos un cubo pro tendremos que marcar muy bien sus
líneas para darle otro tipo de vista

Esta es la practica numero 4 y en esta aprenderemos a utilizar aun mas y poner
en practica las líneas.


glBegin(GL_LINES);

glBegin(GL_QUADS);

Codigo:

//TABLERO DE AJEDREZ


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


}


{


visualización




inicializa();

visualización



}

Muñeco con Formas.


En esta práctica realizamos un muñeco con muchas figuras, como triángulos,
cuadrados, rectángulos, círculos, etc.

Debemos realizar esta practica en una clase solamente ya que es como un
examen para ver como trabajamos y todo lo que hemos aprendido sobre este
programa.


GlBegin (GL_QUADS);

GlBegin (GL_TRIANGLES);

GlBegin (GL_POLYGON);

GlBegin (GL_LINES);

Circulo ();

El código que utilizamos en esta práctica es el siguiente:

Void dibuja (void) //función dibuja
{
GlClear (GL_COLOR_BUFFER_BIT);
//cabello
glColor3f (0.0, 0.0, 0.0);
glVertex2i (280,400);
//cabello
glColor3f (0.0, 0.0, 0.0);

//cabello
glColor3f (0.0, 0.0, 0.0);
//cabello
glColor3f (0.0, 0.0, 0.0);
//cabello
glColor3f (0.0, 0.0, 0.0);
//cabello
glColor3f (0.0, 0.0, 0.0);
//cabello
glColor3f (0.0, 0.0, 0.0);
//cabello
glColor3f (0.0, 0.0, 0.0);
//cabello
glColor3f (0.0, 0.0, 0.0);
GlEnd ();
//cabeza
glColor3f (1.0, 0.8, 0.7); //borra pantalla
Círculo (250, 350,75);
//sonrisa

Circulo (250, 300,15);
//sonrisa
circulo(250,310,15);
//ojos
glColor3f(1.0,1.0,1.0); //borra pantalla
circulo(225,375,10);
//ojos
circulo(225,375,5);
//ojos
circulo(275,375,10);
//ojos
circulo(275,375,5);
//orejas
circulo(325,375,15);
//orejas
circulo(173,375,15);
//cuello
glColor3f(1.0,0.8,0.7);
//cuerpo
glBegin(GL_QUADS);
glColor3f(1.0,0.0,0.0);
//cuello
glColor3f(1.0,0.8,0.7);
//brazo

glEnd();
circulo(140,150,25);
circulo(380,150,25);
glColor3f(1.0,1.0,.0);
glBegin(GL_POLYGON);
glVertex2i(160,10);
glVertex2i(180,10);
glVertex2i(330,10);
glVertex2i(350,10);
glEnd();
glColor3f(0.0,0.0,0.0);
circulo(340,10,20);
circulo(170,10,20);
}

Salida:

ANIMACION CÍRCULO.


En esta práctica realizaremos una animación en Dev c++ esta vez no utilizaremos
cuadrados ni triángulos ahora solo utilizaremos un circulo y unas nuevas
instrucciones que el profesor nos dio.

Lo que tenemos que realizar es que un circulo avance hacia enfrente, hacia abajo,
hacia atrás, hacia arriba, en este orden una y otra vez.

Nos tenemos que guiar con un trabajo que el profesor nos dio pero que solo
avanza hacia enfrente, ahora tenemos que cambiar el código para que realice las
siguientes acciones.

La instrucción que utilizamos fue la siguiente:

if(y>=1 && y<600 && x==1000){
circulo(1000,700-y,40);
glFlush();
y++;
}
El código de toda la práctica es el siguiente:
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();
}

SALIDA:

ANIMACION DEL SISTEMA SOLAR.


En esta practica también vamos a realizar una animación en Dev c++ pero ahora
realizaremos un sistema solar realizaremos nuestro sistema solar con movimiento
tanto de los planetas como de las orbitas.

Podemos ponerle el diseño que nosotros deseemos, tenemos que guiarnos con
una instrucción que el profesor nos pasó y también con su ayuda.

La instrucción que utilizamos fue la siguiente:

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

El código de toda la práctica fue el siguiente:

void circulo(int x, int y, int radio)
{
int angulo=0;
glVertex2f(x,y);

for (angulo=0;angulo<=360; angulo++){ glVertex2f(x +
glEnd();
}
void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto
//sol
glColor3f (1.0, 1.0, 0.0);
circulo( 500,500,50);

//mercurio
glColor3f (1.0, 1.0, 1.0);
circuloc(500,500,2,100);
glColor3f (1.0, 0.0, 0.0);
circulo( 500+ sin(b) * 100,500 + cos(b) * 100,10);
//venus
glColor3f (1.0, 1.0, 1.0);
circuloc(500,500,2,150);
glColor3f (0.5, 0.2, 0.1);
circulo( 500+ sin(a) * 150,500 + cos(a) * 150,15);
//tierra
glColor3f (1.0, 1.0, 1.0);
circuloc(500,500,2,200);
glColor3f (0.08, 0.6, 0.9);
circulo( 500+ sin(c) * 200,500 + cos(c) * 200,20);
//marte
glColor3f (1.0, 1.0, 1.0);
circuloc(500,500,2,250);
glColor3f (1.0, 0.0, 0.0);
circulo( 500+ sin(d) * 250,500 + cos(d) * 250,22);
//jupiter
glColor3f (1.0, 1.0, 1.0);
circuloc(500,500,2,300);
glColor3f (0.4, 0.2, 0.6);
circulo( 500+ sin(e) * 300,500 + cos(e) * 300,23);
//saturno
glColor3f (1.0, 1.0, 1.0);
circuloc(500,500,2,350);
glColor3f (0.3, 0.9, 0.6);
circulo( 500+ sin(f) * 350,500 + cos(f) * 350,20);
//urano
glColor3f (1.0, 1.0, 1.0);
circuloc(500,500,2,400);
glColor3f (0.7, 0.1, 0.6);
circulo( 500+ sin(g) * 400,500 + cos(g) * 400,22);
//neptuno
glColor3f (1.0, 1.0, 1.0);
circuloc(500,500,2,450);
glColor3f (0.8, 0.3, 0.2);
circulo( 500+ sin(k) * 450,500 + cos(k) * 450,23);

a=a+0.09;
b=b+0.08;
c=c+0.07;
d=d+0.06;
e=e+0.05;
f=f+0.04;

g=g+0.03;
k=k+0.02;
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
}

SALIDA:

MOVIMIENTO EN OCHO.


En esta practica también realizaremos una animación pero ahora será con dos
círculos, lo que haremos será que en un dibujo parecido en ocho y ahora tenemos
que hacer que dos círculos se muevan como si fueran un carro en una pista.

La instrucción que utilizamos en esta practica es:

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.01;

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

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

El código completo de esta práctica es el siguiente:

{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(1.0, 1.0, 0.0);
circulo(300, 300, 70);
circulo(300,180,70);
glColor3f(1.0,1.0,1.0);
circulo(300,300,50);
circulo(300,180,50);
glColor3f(0.0,0.0,0.0);

if(a>=6.15 && a<=12.41){
circulo(300+ sin (a)*60,300- cos(a)*60,10);
a=a +0.01;
}

else{
circulo(300 + sin (b) *60,180+cos(b)*60,10);
b=b + 0.01;
if(b>12.4){a=6.15;b=6.15;}
for(int j=0; j<=10; j++) {}
}

glFlush();
glutSwapBuffers();
}

SALIDA.:

SEMAFORO:


En esta practica realizaremos un semáforo, logrando que se cambien de color y
que cuando este en verde parpadee un poco después el amarillo y por ultimo en
color rojo.

El profesor nos paso un trabajo ya terminado y después nos explico como
realizarlo además de que igual nos paso un video tutorial de cómo realizarlo.

El código completo de esta practica es el siguiente:

#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 +
glEnd();
}

void circulo(int x, int y, int radio)
{
int angulo=0;
// glColor3f (1.0, 0.0, 1.0);
glVertex2f(x,y);

for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x +

glEnd();
}

{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0,0.0,1.0);
glBegin(GL_QUADS);
glEnd();

//rojo
circulo(250,400,50);
//amarillo
circulo(250,300,50);
//amarillo
circulo(250,200,50);
}
SALIDA:

PIRAMIDE.

Presentación o Descripción:

En esta practica realizaremos una pirámide que solo se vera por la parte de arriba
para esto tenemos que guiarnos con la instrucción que el profesor ya nos paso
anteriormente.

También con su ayuda realizaremos lo que falta de la práctica.

Esta práctica se realizara más fácilmente con la instrucción Ford para que sea
más fácil.

El código completo de esta práctica es el siguiente:

{int i,a=20;
glColor3f(0.0 , 0.0 , 0.0);
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();

SALIDA:

Proyecto de reneya terminado

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (8)

Destacado

Destacado (20)

Similar a Proyecto de reneya terminado

Similar a Proyecto de reneya terminado (20)

Proyecto de reneya terminado