Tutorial: Creación de un polígono, un triangulo en 3d y 2d con Visual Basic 6.
0 y
OpenGL
Comandos Básicos de OpenGL
OpenGL tiene sus propios tipos en cuanto a variables se refiere. Asi como en
VB 6.0 utilizaremos los conocidos como int, flota, double nos acostumbraremos a
GLint, GLfloat, GLdouble, en realidad son los mismos pero aumentando el prefijo GL
de OpenGL, se declaran de la misma manera que la variable en C y tienen las mismas
propiedades
Las funciones OpenGL empiezan con el prefijo “gl”, en minusculas. Ej. Crear un
vertice (punto).
Usaremos:
glVertex3f (0.0, 0.0, 0.0);
ó:
GLfloat vertice[3]={0.0, 0.0, 0.0};
glVertexfv(vertice);
Ambas funciones crean un vértice situado en el origen de coordenadas del
mundo, es decir x = y = z = 0.0. como se ven en el primer caso la función termina en
“3f” (3 floats). Esto es para indicar que se creara el vértice con 3 valores o variables de
tipo real. (flota). En la segunda declaración termina en “fv” (flota vector), con esto le
indicamos que crearemos el vértice a partir de un arreglo/vector de floats, en el caso del
ejemplo el arreglo es: GLfloat vertice[3]={0.0, 0.0, 0.0};
Tenemos que tener en cuenta que al trabajar con OpenGL se trabaja en 3D, para
esto se agregan las coordenadas para el vértice en el orden X, Y, Z, en caso de trabajar
en 2D solo tenemos que hacer una coordenada igual a 0.0 normalmente la Z.
Empecemos a crear nuestro primer polígono, OpenGL tiene varios tipos
definidos de manera que nos facilita el trabajo para la creación de polígonos entre otros.
Ej.
glBegin(GL_TRIANGLES);
glVertex3f(-1.0, 0.0, 0.0);
glVertex3f(1.0, 0.0, 0.0);
glVertex3f(0.0, 1.0, 0.0);
glEnd();
Este código nos crea un triangulo en 2D ya que como se ve los valores en Z
están a 0.0 para los 3 vértices, entonces esto nos queda con los vértices: (-1.0, 0.0) (1.0,
0.0) (0.0, 1.0) en XY. El poligono se encapsula entre las funciones glBegin y glEnd, el
parametro que recibe la primera sirve para decirle a OpenGL que tipo de poligono desea
crear, en nuestro caso es un triangulo, GL_TRIANGLES es una constante ya definida
en la librería, por claridad es conveniente tabular el código entre glBegin y glEnd tal y
como se ve en el ejemplo. Cualquier código manejado con OpenGL sigue esta
estructura.
Para definir el color de una figura, en este caso nuestro poligono lo realizaremos
con el codigo:
glColor3f(0.5, 0.5, 0.5);
Donde los tres valores son flota y son pasados a la funcion glColor el orden de
sus valores son Rojo, Verde, Azul, con el valor le indicamos la cantidad de que color
deseamos, utiliza el sistema RGB, aplicando la cantidad necesaria de cada uno de estos
colores obtendremos el deseado. El rango de intensidad esta entre 0.0 y 1.0 por lo tanto:
glColor3f(0.0, 0.0, 0.0); corresponde al color negro y glColor3f(1.0, 1.0, 1.0);
corresponde al blanco.
Por consiguiente si queremos hacer un triangulo blanco tendremos este codigo:
glColor3f(1.0, 1.0, 1.0); //primero especificamos el color a blanco
glBegin (GL_TRIANGLES); //definimos que tipo de polígono deseamos en este caso
un triangulo
glVertex3f(-1.0. 0.0, 0.0);//primer punto ó vértice
glVertex3f(1.0, 0.0, 0.0);//segundo punto ó vértice
glVertex3f(0.0, 1.0, 0.0);//tercer punto ó vértice
glEnd();//terminamos la declaración
Al ejecutar cada funcion glVertex, el vertice en cuestion “entra” en el pipeline y
se translada a la posición que hemos especificado para el. Entonces se “mapea” en el
frame buffer (representación en memoria del plano de proyeccion 2D) pasando
posteriormente a la pantalla de nuestro monitor. Asi en este caso tenermos 3 vertices
que sucesivamente entran en el pipeline uno tras otro.
Algo muy importante que se debe tomar en cuenta es que OpenGL no asegura
que la representación en pantalla sea la correcta, para realizar cualquier figura
geometrica se debe seguir un orden concreto en la inserción de los vértices. OpenGL
crea los vercises según el sentido antihorario de las manecillas del reloj. OpenGL
supone la cara “a dibujar” del poligono como la que se define de esta manera.
Las funciones que se pueden utilizar dentro de la funcion glBegin son:
• GL_POINTS: para que todos los vértices indicados entre ambas
funciones se dibujen por separadazo a modo de puntos “libres”.
• GL_LINES: cada dos vértices definidos, se traza automáticamente una
linea que los une.
• GL_LOFYGON: se unen todos los vértices formando un poligono.
• GL_QUADS: cada 4 vertices se unen para formar un cuadrilatero.
• GL_TRIANGLES: cada 3 vertices se unen para formar un triangulo.
• GL_TRIANGLE_STRIP: crea un triangulo con los 3 primeros vértices.
Entonces sucesivamente crea un nuevo triangulo unido al anterior usando
los dos ultimos vértices que se han definido y el actual.
• GL_QUAD_STRIP: igual que el anterior pero con cuadrilateros
En la figura se observa como usando diferentes tipos (GL_POINTS, GL_LINES,
etc.) conseguimos diferentes objetos en pantalla dados unos vértices creados según el
orden que ves en la figura (p0, p1, p2, etc) para los 6 rectangulos de la primera fila, es
decir:
glBegin(TIPO);
glVertex3f(p0x, p0y, p0z);
glVertex3f(p1x, p1y, p1z);
glVertex3f(p2x, p2y, p2z);
glVertex3f(p…x, p…y, p…z);
glVertex3f(p7x, p7y, p7z);
glEnd();
