Está en la página 1de 6

Materia: Graficacin (con OpenGL)

Introduccin a la programacin grafica con OpenGL.


Se muestran a continuacin algunos ejemplos bsicos de programacin grafica. EL
alumno debe editarlos en alguno de los compiladores configurados para soportar la
librera grfica libre OpenGL.
Ejemplo1.
#include<gl\glut.h>
void display()
{
glClearColor(1,1,0,0);
//Color de pantalla
glClear(GL_COLOR_BUFFER_BIT);//limpia la pantalla
glColor3f(1,0,0); //Color de la pluma
//Pintar el Punto
glPointSize(7); //tamao del punto
glBegin(GL_POINTS);
glVertex2f(.1,.6);
glVertex2f(0,0);
glEnd();
glFlush(); // Refuerzo de pintado
}
void main()
{
glutInitWindowSize(500,500); // Tamao de la ventana
glutInitWindowPosition(50,50); // posicion de la ventana
glutCreateWindow("Punto"); // Mombre de la ventana
glutDisplayFunc(display); //llamas a la funcion display
glutMainLoop(); // enalce entre la funcion y el programa principal
}
Ejmplo 2:

/* OpenGL(R) es una marca registrada de Silicon Graphics, Inc. */


/*
* helloOpenGL.c
ste es un ejemplo basico de un progama OpenGL
*/
#include<GL/glut.h>

void display(void)
{
/* Limpia Todos los pixeles */

Graficacin-06

glClear (GL_COLOR_BUFFER_BIT);
/*
dibuja un poligono blanco (rectangulo) con esquinas en
* (0.25, 0.25, 0.0) and (0.75, 0.75, 0.0)
*/
glColor3f (1.0, 1.0, 1.0);
glBegin(GL_POLYGON);
glVertex3f (0.25, 0.25, 0.0);
glVertex3f (0.75, 0.25, 0.0);
glVertex3f (0.75, 0.75, 0.0);
glVertex3f (0.25, 0.75, 0.0);
glEnd();
/* don't wait!
* inicia procesamiento de las Rutinas OpenGL
*/
glFlush ();
}
void init (void)
{
/* selecciona un color de limpiado */
glClearColor (0.0, 0.0, 0.0, 0.0);
/* inicializa los valores de visin */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
}
/*
* Declara el tamao de la ventana Inicial, posicion y modo de
despliegue
* (single buffer and RGBA). Abre una ventan con "Hello" en su barra
de
* titulo. Llama a la rutinas de inicializacion.
* Resgistra las funciones para desplegado grfico.
* Entra a programa prinicipal (loop) y procesa los eventos
*
*/
int main(int argc, char** argv)
{

glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (250, 250);
glutInitWindowPosition (100, 100);
glutCreateWindow ("Hello");
init ();
glutDisplayFunc(display);
glutMainLoop();
return 0;
/* ANSI C requiere que main retorne un int. */

Ejemplo 3: El algoritmo de Bresenham para pintar lneas (completo)


#define BLACK 0

Graficacin-06

#include <GL/glut.h>
#include <stdio.h>
void draw_pixel(int ix, int iy, int value)
{
glBegin(GL_POINTS);
glVertex2i( ix, iy);
glEnd();
}
bres(int x1,int y1,int x2,int y2)
{
int dx, dy, i, e;
int incx, incy, inc1, inc2;
int x,y;
dx = x2 - x1;
dy = y2 - y1;
if(dx < 0) dx = -dx;
if(dy < 0) dy = -dy;
incx = 1;
if(x2 < x1) incx = -1;
incy = 1;
if(y2 < y1) incy = -1;
x=x1;
y=y1;
if(dx > dy)
{
draw_pixel(x,y, BLACK);
e = 2*dy - dx;
inc1 = 2*( dy -dx);
inc2 = 2*dy;
for(i = 0; i < dx; i++)
{
if(e >= 0)
{
y += incy;
e += inc1;
}
else e += inc2;
x += incx;
draw_pixel(x,y, BLACK);
}
}
else
{
draw_pixel(x,y, BLACK);
e = 2*dx - dy;
inc1 = 2*( dx - dy);
inc2 = 2*dx;
for(i = 0; i < dy; i++)
{
if(e >= 0)
{
x += incx;
e += inc1;
}
else e += inc2;

Graficacin-06

y += incy;
draw_pixel(x,y, BLACK);

}
}

void display()
{
glClear(GL_COLOR_BUFFER_BIT);
bres(200, 200, 100, 100);
glFlush();
}
void myinit()
{
glClearColor(1.0, 1.0, 1.0, 1.0);
glColor3f(1.0, 0.0, 0.0);
glPointSize(1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 499.0, 0.0, 499.0);
}
void main(int argc, char** argv)
{
/*

Inicializacion GLUT estndar*/

glutInit(&argc,argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(500,500); /* ventana 500x500 pixeles */
glutInitWindowPosition(0,0); /* coloca la ventana de despliegue en
esq. sup. izq */
glutCreateWindow("Bresenham's Algorithm"); /* ttulo de la
ventana*/
glutDisplayFunc(display); /*llama a la funcion display cuando se
abre la ventana */
myinit(); /* fija o establece los atributos */
glutMainLoop(); /* entra a un ciclo de evento */
}

EJMPLO : Algoritmo para dibujar un circulo mediante el mtodo de Bresenham


#include
#include
#include
#include

<windows.h>
<GL/glut.h>
<stdio.h>
<math.h>

void init(void){
glClearColor(1.0,1.0,0.0,0.0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0.0,200.0,0.0,150.0);
}
void setPixel(GLint x,GLint y)
glBegin(GL_POINTS);

Graficacin-06

glVertex2i(x,y);
glEnd();

}
void Circle(){

int xCenter=100,yCenter=100,r=50;
int x=0,y=r;
int d=3-(2*r);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1,0,0.5);
while(x<=y){
setPixel(xCenter+x,yCenter+y);
setPixel(xCenter+y,yCenter+x);
setPixel(xCenter-x,yCenter+y);
setPixel(xCenter+y,yCenter-x);
setPixel(xCenter-x,yCenter-y);
setPixel(xCenter-y,yCenter-x);
setPixel(xCenter+x,yCenter-y);
setPixel(xCenter-y,yCenter+x);
if (d<0)
d += (4*x)+6;
else
{
d += (4*(x-y))+10;
y -= 1;
}
x++;
}
glFlush();
}
int main(int argc,char **argv){
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowPosition(0,0);
glutInitWindowSize(500,500);
glutCreateWindow("Bresenham Circle");
init();
glutDisplayFunc(Circle);
glutMainLoop();
return 0;
}

EJERCICICIOS:
Graficacin-06

1) Elabore un programa para pintar en la pantalla el siguiente dibujo con OpenGL. Para
pintar las lneas utilice el algoritmo de Bresenham y el del sistema.

2.) Implemente los dos algoritmos restantes para pintar crculos, vistos en clases.
3).Elabore un programa para pintar una tortuga con OpenGL
4) Disee una casita sencilla en Papel y dibjela con OpenGL
5) Disee un algoritmo para dibujar un arco y una elipse

Graficacin-06