Utilizacion de primitivas con OPENGL C++

16
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

description

dibujado de triangulos con librerias OPEN GL con el lenguaje de C++

Transcript of Utilizacion de primitivas con OPENGL C++

Page 1: Utilizacion de primitivas con OPENGL C++

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

Page 2: Utilizacion de primitivas con OPENGL C++

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.

Page 3: Utilizacion de primitivas con OPENGL C++

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

Page 4: Utilizacion de primitivas con OPENGL C++

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:

Page 5: Utilizacion de primitivas con OPENGL C++

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

Page 6: Utilizacion de primitivas con OPENGL C++

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

Page 7: Utilizacion de primitivas con OPENGL C++

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

Page 8: Utilizacion de primitivas con OPENGL C++

PRIMITIVAS

8

glEnd();

/*glflush();*/

}

Y aquí se muestra lo que se imprime en pantalla:

Page 9: Utilizacion de primitivas con OPENGL C++

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

Page 10: Utilizacion de primitivas con OPENGL C++

PRIMITIVAS

10

}

Aquí se muestra lo que se imprime en pantalla:

Page 11: Utilizacion de primitivas con OPENGL C++

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

}

Page 12: Utilizacion de primitivas con OPENGL C++

PRIMITIVAS

12

Aquí se muestra lo que se imprime en pantalla:

Page 13: Utilizacion de primitivas con OPENGL C++

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

Page 14: Utilizacion de primitivas con OPENGL C++

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:

Page 15: Utilizacion de primitivas con OPENGL C++

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.

Page 16: Utilizacion de primitivas con OPENGL C++

PRIMITIVAS

16

Bibliografía HEARN, D., & BAKER, M. P. (2006). GRAFICOS POR COMPUTADORA CON OPENGL. MADRID:

PEARSON.