PRIMITIVAS
1
INSTITUTO TECNOLÓGICO
DE CIUDAD JUÁREZ
INGENIERÍA EN SISTEMAS
COMPUTACIONALES
GRAFICACIÓN
TAREA PROGRAMACIÓN DE PRIMITIVAS UNIDAD I
GL_TRIANGLE_FAN, GL_TRIANGLE_STRIP,
GL_TRIANGLES
LEYVA MONDRAGON FRANCISCO
ROSALES MORALES NOÉ RAMÓN
DOMINGO 06 DE SEPTIEMBRE DE 2015
PRIMITIVAS
2
INTRODUCCION
Por medio de este breve ensayo se conocerá acerca de las librerías que usa al
programar líneas con openGL en c++. Así como ejemplos de las primitivas para
polígonos, que en esta ocasión son formados por triángulos, los cuales
programamos con las primitivas de GL_TRIANGLE_FAN, GL_TRIANGLE_STRIP,
GL_TRIANGLES, y así nos daremos cuenta de cuál de estas primitivas es mejor
manejar.
PRIMITIVAS
3
INDICE PROGRAMACIÓN DE PRIMITIVAS
INTRODUCCIÓN…………………..…………………...………….……………....Página 2 PROGRAMA BASE………………………………………..................................Página 4
PRIMITIVA GL_TRIANGLE_FAN...................................................................Página 9 PRIMITIVA GL_TRIANGLE_STRIP................................................................Página 11 PRIMITIVA GL_TRIANGLES..........................................................................Página 13 CONCLUSIÓN…….………………..……………………………………….…..….Página 16
BIBLIOGRAFÍA…….……………………………………………………….…..….Página 16
PRIMITIVAS
4
PROGRAMA BASE El programa de OpenGL esta organizado en tres procedimientos. El primero es el colocar
todas las inicializaciones y los parámetros de configuración relacionados en el
procedimiento init. El segundo será referenciado por la función de GLUT glutDisplayfunc.
Y el tercer procedimiento es el procedimiento main que contiene las funciones GLUT que
configuran la ventana de visualización y muestran el segmento en pantalla.
Enseguida se muestra el código fuente de este ejemplo:
#include "stdafx.h" #include "stdafx.h" #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 código de base podemos programar lo que queramos dibujar en nuestra
pantalla. En esta ocasión dibujaremos polígonos pero formados por triángulos utilizando
las primitivas.
Enseguida se muestra el código fuente de todo el programa, donde se utilizan las
primitivas:
PRIMITIVAS
5
#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); // TAMAÑO 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
6
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
7
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
8
glEnd();
/*glflush();*/
}
Y aquí se muestra lo que se imprime en pantalla:
PRIMITIVAS
9
PRIMITIVA GL_TRIANGLE_FAN Para N vértices, obtendremos de nuevo N - 2, supuesto que no se repita ninguna posición de vértice y que hayamos incluido al menos tres vértices. Además, los vértices deben especificarse en el orden correcto para poder definir adecuadamente las caras anterior y posterior de cada triángulo. El primer vértice enumerado (en este caso, p l ) formará parte de cada uno de los triángulos de la estructura en ventilador. Si volvemos a enumerar los triángulos y los vértices como n = I, n = 2 , . . . n = N - 2, entonces los vértices para el triángulo n aparecerán en la tabla de polígonos en el orden I, n + l. // I- 2. Por tanto, el triángulo 1 estará definido mediante la lista de vértices ( p l . p2, p3); el triángulo 2 tendrá la ordenación de vértices (pl, p3, p4); el triángulo 3 tendrá sus vértices especificados en el orden (pl, p4, p5) y el triángulo 4 estará descrito mediante la ordenación de vértices (pl, p5, p6)..
Las coordenadas para este polígono se codificarían así: triangulos(200, 200, 290, 110, 320, 220, 200, 300, 80, 220, 110, 110, 290, 110); Y aquí se muestra el método 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
10
}
Aquí se muestra lo que se imprime en pantalla:
PRIMITIVAS
11
PRIMITIVA GL_TRIANGLE_STRIP Suponiendo que no se repita ninguno de los N vértices de la lista, obtendremos N ~ 2 triángulos en la banda de triángulos dibujada por este comando. Obviamente, debemos tener N > 3 o no se podrá mostrar ninguna imagen. Cada uno de los sucesivos triángulos comparte una arista con el triángulo anteriormente definido, por lo que la ordenación de la lista de vértices debe ser la adecuada para garantizar una visualización coherente. Se definirá un triángulo para cada vértice enumerado después de los dos primeros vértices. Así, los primeros tres vértices deben enumerarse en el sentido contrario a las agujas del reloj. Después de eso, el conjunto de tres vértices para cada triángulo subsiguiente estará dispuesto en sentido contrario a las agujas del reloj dentro de la tabla de polígonos.
Las coordenadas para este polígono se codificarían así: triangulos2(500, 100, 600, 300, 700, 100, 800, 300, 900, 100, 1000, 300, 1100, 100);
Y aquí se muestra el método 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();
}
PRIMITIVAS
12
Aquí se muestra lo que se imprime en pantalla:
PRIMITIVAS
13
PRIMITIVA GL_TRIANGLES En este caso, los primeros tres puntos definen los vértices de un triángulo, los siguientes
tres puntos definen el siguiente triángulo, etc. Para cada área de relleno triangular,
especificamos las posiciones de los vértices en sentido contrario a las agujas del reloj.
Con esta constante primitiva se mostrará un conjunto de triángulos desconectados, a
menos que se repitan las coordenadas de algunos vértices. Si no incluimos al menos tres
vértices, no se mostrará nada en la imagen, y si el número de vértices especificados no es
un múltiplo de tres, el vértice o los dos vértices finales no se utilizarán.
Las coordenadas para estos polígonos se codificarían 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 método 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);
PRIMITIVAS
14
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:
PRIMITIVAS
15
CONCLUSIÓN En conclusión se puede decidir por las dos primeras primitivas ya que se utilizan menos
coordenadas y es más sencillo y es menos propenso a errores. Aunque dependiendo de
lo que queramos dibujar se nos acomodaría alguna de estas tres primitivas.
PRIMITIVAS
16
Bibliografía HEARN, D., & BAKER, M. P. (2006). GRAFICOS POR COMPUTADORA CON OPENGL. MADRID:
PEARSON.
Top Related