Benemérita Universidad Autónoma de Puebla

Facultad de Ciencias de la Computación

Materia: Graficación (con OpenGL)

Introducción a la programación grafica con OpenGL.

Se muestran a continuación algunos ejemplos básicos de programación grafica. EL

alumno debe editarlos en alguno de los compiladores configurados para soportar la
librería gráfica 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); //tamaño del punto
glBegin(GL_POINTS);
glVertex2f(.1,.6);
glVertex2f(0,0);

glEnd();
glFlush(); // Refuerzo de pintado
}

void main()
{

glutInitWindowSize(500,500); // Tamaño 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>

Graficación-06 1
void display(void)
{
/* Limpia Todos los pixeles */
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 visión */

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
}

/*
* Declara el tamaño 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 gráfico.
* 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 líneas (completo)

Graficación-06 2
#define BLACK 0
#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;

Graficación-06 3
 }
else e += inc2;
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 estándar*/

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"); /* título 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 método de Bresenham

#include <windows.h>
#include <GL/glut.h>
#include <stdio.h>
#include <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)

Graficación-06 4
 {
glBegin(GL_POINTS);
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;
}

Graficación-06 5
EJERCICICIOS:
1) Elabore un programa para pintar en la pantalla el siguiente dibujo con OpenGL. Para
pintar las líneas utilice el algoritmo de Bresenham y el del sistema.

2.) Implemente los dos algoritmos restantes para pintar circulos, vistos en clases.

3).Elabore un programa para pintar una tortuga con OpenGL

4) Diseñe una casita sencilla en Papel y dibújela con OpenGL

5) Diseñe un algoritmo para dibujar un arco y una elipse

Graficación-06 6