PRIMITIVAS

INSTITUTO TECNOLGICO
DE CIUDAD JUREZ

INGENIERA EN SISTEMAS
COMPUTACIONALES

GRAFICACIN
TAREA PROGRAMACIN DE PRIMITIVAS
UNIDAD I

GL_TRIANGLE_FAN, GL_TRIANGLE_STRIP,
GL_TRIANGLES

LEYVA MONDRAGON FRANCISCO

ROSALES MORALES NO RAMN

DOMINGO 06 DE SEPTIEMBRE DE 2015

PRIMITIVAS

INTRODUCCION
Por medio de este breve ensayo 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.

PRIMITIVAS

INDICE
PROGRAMACIN DE PRIMITIVAS
INTRODUCCIN..........Pgina 2
PROGRAMA BASE..................................Pgina 4
PRIMITIVA GL_TRIANGLE_FAN...................................................................Pgina 9
PRIMITIVA GL_TRIANGLE_STRIP................................................................Pgina 11
PRIMITIVA GL_TRIANGLES..........................................................................Pgina 13
CONCLUSIN.......Pgina 16
BIBLIOGRAFA.....Pgina 16

PRIMITIVAS

PROGRAMA BASE
El programa de OpenGL esta 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.
Enseguida se muestra el cdigo fuente de este ejemplo:
#include
#include
#include
#include
#include

"stdafx.h"
"stdafx.h"
<stdlib.h>
<math.h>
<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:

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

PRIMITIVAS
triangulos(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
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 en un

PRIMITIVAS
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();
}
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();
}
void setPixel (int x,int y)
{
//glPointSize(2);
glBegin(GL_POINTS);
glVertex2i (x, y);// Vertice1

PRIMITIVAS
glEnd();
/*glflush();*/
}

Y aqu se muestra lo que se imprime en pantalla:

PRIMITIVAS

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

PRIMITIVAS
}

Aqu se muestra lo que se imprime en pantalla:

10

PRIMITIVAS

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

11

PRIMITIVAS

Aqu se muestra lo que se imprime en pantalla:

12

PRIMITIVAS

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.

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

13

PRIMITIVAS

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

14

PRIMITIVAS

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

15

PRIMITIVAS

Bibliografa
HEARN, D., & BAKER, M. P. (2006). GRAFICOS POR COMPUTADORA CON OPENGL. MADRID:
PEARSON.

16