Aprendiendo JOGL

Hasta el momento hemos visto los pricipios básicos sobre dibujar líneas y hemos dibujado un cuadrilátero. Utilizaremos esos mismo principios para dibujar una circunferencia utilizando el mismo código simplemente modificando el método display().

Círculo dibujado con JOGL.

Lo que haremos primero será dibujar un hexágono. Para lograr nuestro cometido, dibujaremos 6 vértices de la siguiente manera:

1. El primer vértice lo dibujaremos en la coordenada (4, 0).
2. Haremos rotar dicho vértice 60º (360º/6) y lo volvemos a dibujar en sus nuevas coordenadas.
3. Repetimos el paso anterior 5 veces para dibujar un total de 6 vértices que formarán nuestro hexágono.
   

Recordemos la fórmula para hacer rotar un punto un ángulo , el nuevo punto estará definido por:




Nos ayudaremos de un array de tipo float de dimensiones [6][2], los cuales representarán nuestras 6 coordenadas, éste array lo inicializaremos dentro del contructor.

Dentro de los métodos glBegin() y glEnd() declaramos nuestros vértices:

gl.glBegin(GL.GL_LINE_LOOP);
// Inicializamos el primer vértice
// Coordenada x
punto[0][0] = 4.0f;

// Coordenada y
punto[0][1] = 0.0f;

// Dibujamos el primer vértice
gl.glVertex2d(punto[0][0], punto[0][1]);

/* Dibujamos los 5 vértices restantes haciendo rotar
* el anterior 60º, utilizaremos el equivalente en
* radianes ya que las funciones sin y cos del
* paquete Math de Java trabaja con estos últimos */

for (int i = 1; i<6; i++)
{
// Coordenada x' = x*cos(60º) - y*sin(60º)
punto[i][0] = punto[i-1][0]*Math.cos(Math.toRadians(60)) -
punto[i-1][1]*Math.sin(Math.toRadians(60));

// Coordenada y' = x*sin(60º) + y*cos(60º)
punto[i][1] = punto[i-1][0]*Math.sin(Math.toRadians(60)) +
punto[i-1][1]*Math.cos(Math.toRadians(60));

// Dibujamos el nuevo vértice obtenido
gl.glVertex2d(punto[i][0], punto[i][1]);
}
gl.glEnd();

Al compilar y ejecutar el código modificado nos muestra un resultado como el siguiente:

Hexágono dibujado con JOGL.

Ahora volveremos a modificar el código, pero ahora, para dibujar un octágono. Utilizaremos el mismo metodo utilizado anteriormente, sólo que en esta ocasión en vez de rotar 60º (360º/6) el vértice lo haremos rotar 45º (360º/8) y dicho vértice lo dibujaremos 8 veces.

Nos ayudaremos de un array de tipo float de dimensiones [8][2], los cuales representarán nuestras 8 coordenadas, éste array lo inicializaremos dentro del contructor.

Dentro de los métodos glBegin() y glEnd() declaramos nuestros vértices:

gl.glBegin(GL.GL_LINE_LOOP);
// Inicializamos el primer vértice
// Coordenada x
punto[0][0] = 4.0f;

// Coordenada y
punto[0][1] = 0.0f;

// Dibujamos el primer vértice
gl.glVertex2d(punto[0][0], punto[0][1]);

/* Dibujamos los 8 vértices restantes haciendo rotar
* el anterior 45º, utilizaremos el equivalente en
* radianes ya que las funciones sin y cos del
* paquete Math de Java trabaja con estos últimos */

for (int i = 1; i<8; i++)
{
// Coordenada x' = x*cos(45º) - y*sin(45º)
punto[i][0] = punto[i-1][0]*Math.cos(Math.toRadians(45)) -
punto[i-1][1]*Math.sin(Math.toRadians(45));

// Coordenada y' = x*sin(45º) + y*cos(45º)
punto[i][1] = punto[i-1][0]*Math.sin(Math.toRadians(45)) +
punto[i-1][1]*Math.cos(Math.toRadians(45));

// Dibujamos el nuevo vértice obtenido
gl.glVertex2d(punto[i][0], punto[i][1]);
}
gl.glEnd();

Al compilar y ejecutar el código modificado nos muestra un resultado como el siguiente

Octágono dibujado con JOGL.

Como se puede apreciar en los ejemplos anteriores, si seguimos aumentando los lados de las figuras, estas van adquiriendo más la forma de una circunferencia. Modifiquemos una vez más el código pero esta vez para dibujar un polígono circular de 360º. Utilizaremos el mismo metodo utilizado anteriormente, sólo que en esta ocasión en vez de rotar 45º (360º/8) el vértice lo haremos rotar solamente 1º (360º/360) y dicho vértice lo dibujaremos 360 veces.

Nos ayudaremos de un array de tipo float de dimensiones [360][2], los cuales representarán nuestras 360 coordenadas, éste array lo inicializaremos dentro del contructor.

Dentro de los métodos glBegin() y glEnd() declaramos nuestros vértices:

gl.glBegin(GL.GL_LINE_LOOP);
// Inicializamos el primer vértice
// Coordenada x
punto[0][0] = 4.0f;

// Coordenada y
punto[0][1] = 0.0f;

// Dibujamos el primer vértice
gl.glVertex2d(punto[0][0], punto[0][1]);

/* Dibujamos los 359 vértices restantes haciendo rotar
* el anterior 1º, utilizaremos el equivalente en
* radianes ya que las funciones sin y cos del
* paquete Math de Java trabaja con estos últimos */

for (int i = 1; i<360; i++)
{
// Coordenada x' = x*cos(1º) - y*sin(1º)
punto[i][0] = punto[i-1][0]*Math.cos(Math.toRadians(1)) -
punto[i-1][1]*Math.sin(Math.toRadians(1));

// Coordenada y' = x*sin(1º) + y*cos(1º)
punto[i][1] = punto[i-1][0]*Math.sin(Math.toRadians(1)) +
punto[i-1][1]*Math.cos(Math.toRadians(1));

// Dibujamos el nuevo vértice obtenido
gl.glVertex2d(punto[i][0], punto[i][1]);
}
gl.glEnd();

Al compilar y ejecutar el código modificado nos muestra un resultado como el siguiente:

Circunferencia dibujada con JOGL.

Y ahí tenemos nuestra circunferencia hecha con JOGL, como los lados están tan juntos y tan pequeños son casi imperceptibles dándonos el aspecto de un círculo. Lo anterior lo hicimos porque JOGL no ofrece funciones específicas para dibujar circunferencias.

Si desean descargar los códigos fuente de las figuras mostradas en los ejemplos simplemente den click en alguno de los siguientes enlaces:

Descargar código fuente dibujarHexagono.java
Descargar código fuente dibujarOctagono.java
Descargar código fuente dibujaCircunferencia.java

NOTA FINAL
En los ejemplos utilizamos un array bidimensional para dibujar los vértices, ésto fue simplemente para hacerlo entendible. Solo como recomendación, para ahorrar memoria del sistema, no utilicen un array ya que entre más grande sea éste más memoria ocuparán. En vez de utilizar un array bidemensional, simplemente utilicen dos variables llamadas, digamos, coordenadaX y coordenadaY y sobreescribánlas en cada ciclo for utilizando otras dos variables auxiliares. Descarguen el siguiente código fuente para ver la manera correcta de hacerlo:

Descargar código fuente dibujaCircunferencia.java sin utilizar array bidimensional.