Contenido

INTRODUCCION.............................................................................................................................. 1
PROCEDIMIENTO ........................................................................................................................... 1
CODIGO ........................................................................................................................................ 1
RESULTADO DESPUES DE COMPILAR............................................................................... 7
PRIMITIVA GL_TRIANGLE_FAN ............................................................................................. 8
PRIMITIVA GL_TRIANGLE_STRIP .......................................................................................... 9
PRIMITIVA GL_TRIANGLES................................................................................................... 11
CONCLUCION ................................................................................................................................ 14
BIBLIOGRAFA Y REFERENCIAS DE INTERNET ................................................................... 14

INTRODUCCION
Se conocer acerca de las libreras que usa al programar lneas con OpenGL en C++.
As como ejemplos de las primitivas para polgonos, que en esta ocasin son formados
por tringulos, los cuales programamos con las primitivas de GL_TRIANGLE_FAN,
GL_TRIANGLE_STRIP, GL_TRIANGLES, y as nos daremos cuenta de cul de estas
primitivas es mejor manejar y as reducir cdigo en la elaboracin de figuras con OpenGL
PROCEDIMIENTO
El programa de OpenGL est organizado en tres procedimientos. El primero es el colocar
todas las inicializaciones y los parmetros de configuracin relacionados en el
procedimiento init. El segundo ser referenciado por la funcin de GLUT glutDisplayfunc.
Y el tercer procedimiento es el procedimiento main que contiene las funciones GLUT que
configuran la ventana de visualizacin y muestran el segmento en pantalla.

Cdigo fuente de este ejemplo

CODIGO
#include "stdafx.h"
#include "stdafx.h"
1

#include <stdlib.h>
#include <math.h>
#include <GL/glut.h>
void init (void)
{
glClearColor ( 1.0, 1.0, 1.0, 0.0);
glMatrixMode (GL_PROJECTION);
gluOrtho2D ( 0.0, 200.0, 0.0, 150.0);
}
void main ( int argc, char *argv )
{
glutInit (&argc,&argv) ;
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition (50 , 100 );
glutInitWindowSize (400 , 300 );
glutCreateWindow( "Programa de ejemplo de OpenGL" ) ;
init ( );
glutDisplayFunc () ;
glutMainLoop ( ) ;
}
void setPixel (int x,int y)
{
//glPointSize(2);
glBegin(GL_POINTS);
glVertex2i (x, y);// Vertice1
glEnd();
/*glflush();*/
}

Con este cdigo de base podemos programar lo que queramos dibujar en nuestra
pantalla. En esta ocasin dibujaremos polgonos pero formados por tringulos utilizando
las primitivas.
Enseguida se muestra el cdigo fuente de todo el programa, donde se utilizan las
primitivas:

#include "stdafx.h"
#include "stdafx.h"
#include <stdlib.h>
#include <math.h>
#include <GL/glut.h>
void init (void);
void DibujaLinea (void);
void triangulos(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, int x5,
int y5, int x6, int y6);
void triangulos2(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, int x5,
int y5, int x6, int y6);
void triangulos3(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, int x5,
int y5, int x6, int y6, int x7, int y7, int x8, int y8, int x9, int y9, int x10, int y10, int x11, int
y11, int x12, int y12, int x13, int y13, int x14, int y14);
void triangulos4(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, int x5,
int y5, int x6, int y6, int x7, int y7, int x8, int y8, int x9, int y9, int x10, int y10, int x11, int
y11, int x12, int y12, int x13, int y13, int x14, int y14);
inline int round (const float a) {
return int (a + 0.5);
}
void setPixel (int x,int y);
void main (int argc, char** argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
3

glutInitWindowPosition (50,100); // POSICION INICIAL

glutInitWindowSize(400,400); // TAMAO DE VENTANA
glutCreateWindow("TRIANGULOS");
init();
glutDisplayFunc (DibujaLinea);
glutMainLoop();
}
void init (void)
{
glClearColor(1.0,1.0,1.0, 0.0); //Estamos asignando un color a la ventana, se basa en
RGB + 1 color alfa.
glMatrixMode(GL_PROJECTION);
gluOrtho2D (0.0, 1150.0, 0.0, 1020.0);
}
void DibujaLinea (void)
{
glClear(GL_COLOR_BUFFER_BIT); // Visualizamos el color de la ventana

200, 200, 290, 110, 320, 220, 200, 300, 80, 220, 110, 110, 290, 110);
triangulos2(500, 100, 600, 300, 700, 100, 800, 300, 900, 100, 1000, 300, 1100, 100);
triangulos3(250, 750, 380, 620, 400, 770, 250, 750, 400, 770, 250, 900, 250, 750, 250,
900, 100, 770, 250, 750, 100, 770, 120, 620, 250, 750, 120, 620, 380, 620);
triangulos4(500, 600, 600, 800, 700, 600, 600, 800, 800, 800, 700, 600, 700, 600, 800,
800, 900, 600, 900, 600, 800, 800, 1000, 800, 900, 600, 1000, 800, 1100, 600);
glFlush();
}
void triangulos(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, int x5,
int y5, int x6, int y6)
{
glBegin (GL_TRIANGLE_FAN);
glColor3f (1.0, 0.0, 0.0); //Le damos color a nuestro objeto
4

glVertex2i (x0, y0) ; //0

glVertex2i (x1, y1); //1
glVertex2i (x2, y2); //2
glVertex2i (x3, y3);//3
glVertex2i (x4, y4);//4
glVertex2i (x5, y5);//5
glVertex2i (x6, y6);//6 para cerrar
glEnd();
glFlush();
}
void triangulos2(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, int x5,
int y5, int x6, int y6)
{
glBegin (GL_TRIANGLE_STRIP);
glColor3f (1.0, 1.0, 0.0); //Le damos color a nuestro objeto en un
glVertex2i (x0, y0) ; //0
glVertex2i (x1, y1); //1
glVertex2i (x2, y2); //2
glVertex2i (x3, y3);//3
glVertex2i (x4, y4);//4
glVertex2i (x5, y5);//5
glVertex2i (x6, y6);//6 para cerrar
glEnd();
glFlush();
}
void triangulos3(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, int x5,
int y5, int x6, int y6, int x7, int y7, int x8, int y8, int x9, int y9, int x10, int y10, int x11, int
y11, int x12, int y12, int x13, int y13, int x14, int y14)
{
glBegin (GL_TRIANGLES);

glColor3f (0.0, 1.0, 0.0); //Le damos color a nuestro objeto

(x0, y0) ; //0
glVertex2i (x1, y1); //1
glVertex2i (x2, y2); //2
glVertex2i (x3, y3);//3
glVertex2i (x4, y4);//4
glVertex2i (x5, y5);//5
glVertex2i (x6, y6);//6
glVertex2i (x7, y7);
glVertex2i (x8, y8);
glVertex2i (x9, y9);
glVertex2i (x10, y10);
glVertex2i (x11, y11);
glVertex2i (x12, y12);
glVertex2i (x13, y13);
glVertex2i (x14, y14);
glEnd();
glFlush();
}
void triangulos4(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, int x5,
int y5, int x6, int y6, int x7, int y7, int x8, int y8, int x9, int y9, int x10, int y10, int x11, int
y11, int x12, int y12, int x13, int y13, int x14, int y14)
{
glBegin (GL_TRIANGLES);
glColor3f (0.0, 0.0, 1.0); //Le damos color a nuestro objeto en un
glVertex2i (x0, y0) ; //0
glVertex2i (x1, y1); //1
glVertex2i (x2, y2); //2
glVertex2i (x3, y3);//3
glVertex2i (x4, y4);//4
glVertex2i (x5, y5);//5
6

glVertex2i (x6, y6);//6

glVertex2i (x7, y7);
glVertex2i (x8, y8);
glVertex2i (x9, y9);
glVertex2i (x10, y10);
glVertex2i (x11, y11);
glVertex2i (x12, y12);
glVertex2i (x13, y13);
glVertex2i (x14, y14);
glEnd();
glFlush();
}
void setPixel (int x,int y)
{
//glPointSize(2);
glBegin(GL_POINTS);
glVertex2i (x, y);// Vertice1
glEnd();
/*glflush();*/
}

RESULTADO DESPUES DE COMPILAR

PRIMITIVA GL_TRIANGLE_FAN
Para N vrtices, obtendremos de nuevo N - 2, supuesto que no se repita ninguna
posicin de vrtice y que hayamos incluido al menos tres vrtices. Adems, los vrtices
deben especificarse en el orden correcto para poder definir adecuadamente las caras
anterior y posterior de cada tringulo. El primer vrtice enumerado (en este caso, p l )
formar parte de cada uno de los tringulos de la estructura en ventilador. Si volvemos a
enumerar los tringulos y los vrtices como n = I, n = 2 , . . . n = N - 2, entonces los
vrtices para el tringulo n aparecern en la tabla de polgonos en el orden I, n + l. // I- 2.
Por tanto, el tringulo 1 estar definido mediante la lista de vrtices ( p l . p2, p3); el
tringulo 2 tendr la ordenacin de vrtices (pl, p3, p4); el tringulo 3 tendr sus vrtices
especificados en el orden (pl, p4, p5) y el tringulo 4 estar descrito mediante la
ordenacin de vrtices (pl, p5, p6)..

Las coordenadas para este polgono se codificaran as:

triangulos(200, 200, 290, 110, 320, 220, 200, 300, 80, 220, 110, 110, 290, 110);
Y aqu se muestra el mtodo en el cual se puede observar que si inicia con el 0 pero
termina con 6 para poder cerrar la figura:
8

void triangulos(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, int x5,
int y5, int x6, int y6)
{
glBegin (GL_TRIANGLE_FAN);
glColor3f (1.0, 0.0, 0.0); //Le damos color a nuestro objeto
glVertex2i (x0, y0) ; //0
glVertex2i (x1, y1); //1
glVertex2i (x2, y2); //2
glVertex2i (x3, y3);//3
glVertex2i (x4, y4);//4
glVertex2i (x5, y5);//5
glVertex2i (x6, y6);//6 para cerrar
glEnd();
glFlush();
}
Aqu se muestra lo que se imprime en pantalla:

PRIMITIVA GL_TRIANGLE_STRIP
Suponiendo que no se repita ninguno de los N vrtices de la lista, obtendremos N ~ 2
tringulos en la banda de tringulos dibujada por este comando. Obviamente, debemos
tener N > 3 o no se podr mostrar ninguna imagen. Cada uno de los sucesivos tringulos
comparte una arista con el tringulo anteriormente definido, por lo que la ordenacin de
9

la lista de vrtices debe ser la adecuada para garantizar una visualizacin coherente. Se
definir un tringulo para cada vrtice enumerado despus de los dos primeros vrtices.
As, los primeros tres vrtices deben enumerarse en el sentido contrario a las agujas del
reloj. Despus de eso, el conjunto de tres vrtices para cada tringulo subsiguiente
estar dispuesto en sentido contrario a las agujas del reloj dentro de la tabla de
polgonos.

Las coordenadas para este polgono se codificaran as:

triangulos2(500, 100, 600, 300, 700, 100, 800, 300, 900, 100, 1000, 300, 1100, 100);
Y aqu se muestra el mtodo en el cual se puede observar que si inicia con el 0 y termina
con 6 para poder cerrar la figura
void triangulos2(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, int x5,
int y5, int x6, int y6)
{
glBegin (GL_TRIANGLE_STRIP);
glColor3f (1.0, 1.0, 0.0); //Le damos color a nuestro objeto en un
glVertex2i (x0, y0) ; //0
glVertex2i (x1, y1); //1
glVertex2i (x2, y2); //2
glVertex2i (x3, y3);//3
glVertex2i (x4, y4);//4
glVertex2i (x5, y5);//5
glVertex2i (x6, y6);//6 para cerrar
glEnd();
glFlush();
10

Aqu se muestra lo que se imprime en pantalla:

PRIMITIVA GL_TRIANGLES
En este caso, los primeros tres puntos definen los vrtices de un tringulo, los siguientes
tres puntos definen el siguiente tringulo, etc. Para cada rea de relleno triangular,
especificamos las posiciones de los vrtices en sentido contrario a las agujas del reloj.
Con esta constante primitiva se mostrar un conjunto de tringulos desconectados, a
menos que se repitan las coordenadas de algunos vrtices. Si no incluimos al menos tres
vrtices, no se mostrar nada en la imagen, y si el nmero de vrtices especificados no
es un mltiplo de tres, el vrtice o los dos vrtices finales no se utilizarn

11

Las coordenadas para estos polgonos se codificaran as:

triangulos3(250, 750, 380, 620, 400, 770, 250, 750, 400, 770, 250, 900, 250, 750, 250,
900, 100, 770, 250, 750, 100, 770, 120, 620, 250, 750, 120, 620, 380, 620);
triangulos4(500, 600, 600, 800, 700, 600, 600, 800, 800, 800, 700, 600, 700, 600, 800,
800, 900, 600, 900, 600, 800, 800, 1000, 800, 900, 600, 1000, 800, 1100, 600);
Y aqu se muestra el mtodo que utiliz:
void triangulos3(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, int x5,
int y5, int x6, int y6, int x7, int y7, int x8, int y8, int x9, int y9, int x10, int y10, int x11, int
y11, int x12, int y12, int x13, int y13, int x14, int y14)
{
glBegin (GL_TRIANGLES);
glColor3f (0.0, 1.0, 0.0); //Le damos color a nuestro objeto en un
glVertex2i (x0, y0) ; //0
glVertex2i (x1, y1); //1
glVertex2i (x2, y2); //2
glVertex2i (x3, y3);//3
glVertex2i (x4, y4);//4
glVertex2i (x5, y5);//5
glVertex2i (x6, y6);//6
glVertex2i (x7, y7);
glVertex2i (x8, y8);

glVertex2i (x9, y9);

glVertex2i (x10, y10);
glVertex2i (x11, y11);
glVertex2i (x12, y12);
glVertex2i (x13, y13);
glVertex2i (x14, y14);
12

glEnd();
glFlush();
}
void triangulos4(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, int x5,
int y5, int x6, int y6, int x7, int y7, int x8, int y8, int x9, int y9, int x10, int y10, int x11, int
y11, int x12, int y12, int x13, int y13, int x14, int y14)
{
glBegin (GL_TRIANGLES);
glColor3f (0.0, 0.0, 1.0); //Le damos color a nuestro objeto en un
glVertex2i (x0, y0) ; //0
glVertex2i (x1, y1); //1
glVertex2i (x2, y2); //2
glVertex2i (x3, y3);//3
glVertex2i (x4, y4);//4
glVertex2i (x5, y5);//5
glVertex2i (x6, y6);//6
glVertex2i (x7, y7);
glVertex2i (x8, y8);
glVertex2i (x9, y9);
glVertex2i (x10, y10);
glVertex2i (x11, y11);
glVertex2i (x12, y12);
glVertex2i (x13, y13);
glVertex2i (x14, y14);
glEnd();
glFlush();
}

Aqu se muestra lo que se imprime en pantalla:

13

CONCLUCION
En conclusin se puede decidir por las dos primeras primitivas ya que se utilizan menos
coordenadas y es ms sencillo y es menos propenso a errores. Aunque dependiendo de
lo que queramos dibujar se nos acomodara alguna de estas tres primitivas.

BIBLIOGRAFA Y REFERENCIAS DE INTERNET

Grficos por computadora con OpenGL
Tercera edicin
DONALD HEARN
M. PAULINE BAKER
Indiana University - Purdue University

14