Post on 01-Mar-2018
7/26/2019 librerias opengl
1/14
1
ContenidoINTRODUCCION.............................................................................................................................. 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 mainque 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"
7/26/2019 librerias opengl
2/14
2
#include
#include
#include
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();*/
}
7/26/2019 librerias opengl
3/14
3
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
#include
#include
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);
7/26/2019 librerias opengl
4/14
4
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
7/26/2019 librerias opengl
5/14
5
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);
7/26/2019 librerias opengl
6/14
6
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
7/26/2019 librerias opengl
7/14
7
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
7/26/2019 librerias opengl
8/14
8
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:
7/26/2019 librerias opengl
9/14
9
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 cerrarglEnd();
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
7/26/2019 librerias opengl
10/14
10
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();
7/26/2019 librerias opengl
11/14
11
}
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
7/26/2019 librerias opengl
12/14
12
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);
7/26/2019 librerias opengl
13/14
13
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); //2glVertex2i (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:
7/26/2019 librerias opengl
14/14
14
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 INTERNETGrficos por computadora con OpenGLTercera edicinDONALD HEARNM. PAULINE BAKERIndiana University - Purdue University