OpenGL es un API multilenguaje y multiplataforma para escribir aplicaciones que produzcan gráficos 2D y 3D. El estándar define poco más de 250 funciones diferentes para crear escenas tridimensionales a partir de primitivas geométricas básicas. Para quien no la conozca, OpenGL data de 1992 creada por la compañía Silicon Graphics Inc (Ahora parte de HP) y mantenida actualmente por el ARB Working Group.
En Java, es posible desarrollar aplicaciones OpenGL gracias a diferentes frameworks y librerías, siendo JOGL una de las antiguas y estables soportando hasta la especificación 4.5 razón por la cual se vuelve la opción perfecta para trabajar este tipo de aplicaciones ¡Manos a la obra!
Tabla de Contenido
Descargando JOGL en nuestro equipo
El primer paso es simplemente ir a su sitio web y dar click en la opción Builds / Downloads.
En la página de descargas, vamos a la sección que lleva el mismo nombre y damos click en el enlace: Current > zip.
Necesitamos descargar 3 archivos de tipo 7zip: gluegen-javadoc.7z, jogamp-all-platforms.7z y jogl-javadoc.7z
Una vez descargados los 3 archivos, necesitamos extraer su contenido en una carpeta donde podamos trabajar.
Como resultado, debemos obtener 3 carpetas:
Configurando Eclipse para usar JOGL
Es hora de abrir Eclipse. Después de que el programa cargue, vamos al menú Window y elegimos la opción Preferences.
En la ventana de diálogo, vamos a la opción Java, luego Build Path y finalmente User Libraries.
Presionamos el botón New, escribimos el User library name y presionamos el botón OK.
Con el nombre definido, necesitamos agregar lo que hemos descargado. Presionemos el botón Add External JARs.
Dentro de la carpeta jogamp-all-platforms encontramos la subcarpeta jar, ahí dentro tomaremos 2 archivos: gluegen-rt.jar, jogl-all.jar
Una ver cargados los dos archivos jar, necesitamos pedirle a Eclipse que utilice las librerías nativas que acompañan a nuestros archivos. Para lograr esto, seleccionamos gluegen-rt, damos click en Native library location y presionamos el botón Edit.
En la siguiente ventana, presionamos el botón External Folder.
Buscamos dentro de nuestra carpeta jogamp-all-platforms una subcarpeta llamada lib.
Finalmente, hacemos lo mismo con el archivo jogl-all.jar
Regresemos a gluegen-rt.jar, es hora de agregar la documentación, seleccionamos la opción Javadoc location y presionamos el botón Edit.
En la ventana de diálogo, presionamos el botón Browse debajo de la sección Javadoc URL.
En la carpeta gluegen, encontraremos la sub carpeta javadoc, la seleccionamos y presionamos el botón Seleccionar carpeta.
Cuando regresemos a la ventana anterior, presionamos el botón Validate.
Si la documentación es correcta, obtendremos este mensaje de confirmación.
Presionemos OK a las dos ventanas anteriores.
Regresando a nuestra primera ventana, ahora agregaremos la documentación de jogl-all.jar, tal y como hicimos hace unos minutos, observe la imagen.
No olvidemos validar la documentación.
Ahora que ya terminamos de configurar Eclipse, presionemos el botón Apply and Close.
Creando un proyecto Eclipse con JOGL
Iniciemos un nuevo proyecto, para ello vamos a File, New y seleccionamos Java Project.
Renombremos el proyecto como primerJOGL, recomiendo también cambiar la ubicación a una carpeta de nuestra elección usando desmarcando la opción Use default location y presionando el botón Browse. Cuando terminemos, presionemos el botón Next.
Después encontraremos una nueva ventana. En esa ventana, nos movemos a la sección Libraries y presionamos el botón Add Library.
A continuación, seleccionamos User Library y presionamos Next.
En la siguiente ventana, seleccionamos JOGL y presionamos Finish.
De regreso a la ventana anterior, presionamos Finish para poder iniciar nuestro proyecto.
Finalmente nos pedirá crear un módulo, no es realmente necesario, así que presionemos el botón Don’t create.
Como nota hasta este punto: En ocasiones sucedía que Eclipse no agregaba la librería y me obligaba a repetir el proceso 1 o 2 veces. No tengo idea si sea un bug, pero dejo la nota por si le sucede a alguien.
Con nuestro proyecto en blanco, necesitamos añadir un package. Presionamos el botón derecho del ratón sobre la carpeta src, seleccionamos New y luego Package.
Establecemos el nombre de nuestro paquete y presionamos Finish.
Por supuesto, necesitamos una clase, sobre nuestro nuevo package presionamos el botón derecho del ratón, elegimos New y luego Class.
En la sección Name de la ventana de diálogo, establecemos el nombre a Renderer (En realidad, puede ser como uno quiera) marcamos la opción public static void main y presionamos Finish.
Programando una ventana OpenGL básica
La espera ha sido larga, pero vale la pena. Es hora de programar nuestra ventana típica. Para comenzar, hagamos que nuestra clase herede de JFrame y que implemente el escucha de evento básico GLEventListener. Esto último nos pedirá que hagamos import a com.jogamp.opengl
Si todo salió bien, Eclipse nos pedirá que agreguemos los métodos básicos de GLEventListener.
Inmediatamente después de eso, se nos pedirá añadir un serial versión ID.
Es hora de crear el constructor de nuestra clase:
public Renderer(){
}
Trabajemos dentro de la clase. Con super, establezcamos el título de la ventana:
super("Primer aplicación JOGL");
Establezcamos el tamaño de la ventana con setSize.
this.setSize(640, 480);
Centremos la ventana al colocar el valor del método setLocationRelativeTo a null
this.setLocationRelativeTo(null);
Con el método setDefaultCloseOperation hagamos que la ventana se cierre como normalmente lo haría un JFrame con el parámetro EXIT_ON_CLOSE.
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Evitemos que la ventana pueda ser re-dimensionada con el método setResizable en false.
this.setResizable(false);
Lo siguiente es crear un perfil de nuestra aplicación, esto nos permite definir cual de las especificaciones de OpenGL podemos usar. En nuestro caso usaremos la especificación 2 o GL2 con el singleton GLProfile:
GLProfile profile = GLProfile.get(GLProfile.GL2);
Dado que GLProfile permite que la ventana tome todo lo necesario de la especificación que le asignamos, necesitamos cargar todos los datos de contexto con GLCapabilities.
GLCapabilities caps = new GLCapabilities(profile);
Luego, creamos un canvas OpenGL con GLCanvas y la aplicamos nuestra variable tipo GLCapabilities.
GLCanvas canvas = new GLCanvas(caps);
Cuando hagamos eso, necesitaremos añadir el import com.jogamp.opengl.awt
Le aplicamos el GLEventListener a nuestro canvas.
canvas.addGLEventListener(this);
Añadimos el canvas a nuestra clase.
this.add(canvas);
Hacemos visible nuestra ventana.
this.setVisible(true);
Hacemos que el canvas mantenga el enfoque sobre nuestra ventana con el método requestFocusInWindow.
canvas.requestFocusInWindow();
De los 4 métodos que tiene GLEventListener, tomamos el método display, ya que es el adecuado para mostrar lo que hagamos en el canvas. Este método tiene un parámetro de tipo GLAutoDrawable.
Creamos una variable de tipo GL2 y le pedimos que asimile los valores de la variable de tipo GLAutoDrawable, estos valores provienen del perfil que creamos al inicio.
GL2 gl = drawable.getGL().getGL2();
Preparamos el color de fondo de la ventana con la función glClearColor que acepta 4 parámetros que representa: Rojo, Verde, Azul y Alpha en valores flotantes de 0.0 a 1.0. En este ejemplo, aplicamos un color rojo de fondo.
gl.glClearColor(1.0f, 0.0f, 0.0f, 0.0f);
Limpiamos la pantalla con glClear y le pedimos que agregue un buffer de color y uno de profundidad.
gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
Finalmente hacemos un flush.
gl.glFlush();
Ejecutemos la aplicación para ver el resultado.
Es posible que obtengamos algunos Warning, el más común es el de la imagen que se presenta abajo. Esto se debe a un posible problema de compatibilidad de JOGL con las versiones más recientes de Java.
¡Ayuda! He intentado probar los ejemplos y tengo errores
JOGL tiene algunos problemas serios con el JDK después de la versión 11. La mayoría de los errores de compilación que obtuve era confusos y las soluciones que proponían en muchos foros y blogs pueden ser muy complicadas para programadores novatos o para aquellos que están desarrollando contra reloj. Así que lo mejor para eliminar la mayoría de errores (qué no sean detalles de captura o mala escritura) es obligar a Eclipse a usar la versión 11.
Para lograr esto, sólo necesitamos añadir la versión 11 que podemos obtener en su versión open, desde su página de descarga, al dar click en la versión correspondiente a nuestro sistema operativo.
Inmediatamente, lo descargamos a una ubicación donde lo podamos utilizar.
A continuación, utilizando el software de empaquetado que tengamos, extraemos su contenido.
Debemos obtener una carpeta llamada jdk-11.
Regresamos a Eclipse y vamos a Window y luego Preferences.
Entramos a Java, luego Installed JREs. Una vez ahí, presionamos el botón Add.
En la ventana de diálogo, seleccionamos Standard VM y presionamos el botón Next.
A continuación, presionamos el botón Directory de la sección JRE home para localizar la carpeta que acabamos de extraer. Una vez encontrada, presionamos el botón Seleccionar carpeta.
Una vez seleccionada la carpeta, las demás opciones se llenaran en automático. Debe ser como se muestra en la imagen. Al finalizar, se presiona el botón Finish.
Al regresar a la ventana anterior, solo tenemos que marcar el JDK 11 y desmarcar el JDK que estemos usando actualmente. Una vez realizado eso, presionamos el botón Apply and Close.
CON ESO YA DEBERÍA SER POSIBLE TRABAJAR CON JOGL
Dibujemos una primitiva básica OpenGL
Dibujemos una primitiva básica, para poder hacer esto, necesitamos entender como funciona el vertex buffer ya que es el encargado de dibujar las primitivas, entre otras cosas. En OpenGL, vamos a utilizar el siguiente sistema de coordenadas.
Por ahora, dejaremos el eje Z en cero, ya que buscamos dibujar un simple triángulo. Entonces, definimos los 3 vértices del triángulo:
Si unimos los vértices, podemos ver la figura completa.
Vamos a programarlo. Justo después de colocar los buffers con glClear, iniciaremos nuestra figura con el método glBegin y con la constante GL_TRIANGLES le diremos que es un triángulo.
gl.glBegin(GL.GL_TRIANGLES);
Ahora con la función glVertex3f le pasaremos los 3 vértices de nuestro ejemplo en punto flotante.
gl.glVertex3f(-0.5f, -0.5f, 0.0f);
gl.glVertex3f(0.0f, 0.5f, 0.0f);
gl.glVertex3f(0.5f, -0.5f, 0.0f);
Por último, finalicemos con glEnd.
gl.glEnd();
El resultado debe verse así:
¿Te ha resultado? Déjanos saber en los comentarios aquí abajo, en nuestra cuenta de twitter @cablenaranja7 o en nuestra página de facebook.
Docente, IT Manager, Blogger & Developer. Escribo por diversión, educo por pasión. | Grandstanding is not my thing.
Hola, si me podrían ayudar. Tengo una maquina con sistema operativo ubuntu 20.04.01 y hice lo qué especifican en el tutorial pero no me funciona, ya lo intenté muchas veces, se instala de otra manera en Ubuntu? Agradecería qué mr respondan pronto.. Saludos
Saludos Javier. En teoría debería ser más o menos igual ¿En qué parte te quedaste?
Muchas gracias me ayudo bastante la explicación que dio
hola buenas gtardes y un gran saludo, tengo una duda estamos trabajando una actividad e la escuela y tenemos que instalar el plugin OpenGL de JOGL y me gustaria me explicaran como se instala, ya que eclipse no lo he maneja y no se si se maneje igual que NetBeans
Saludos. Se instala igual. La única diferencia es que en Netbeans la opción para instalar librerías externas (JOGL no funciona como plugin en Netbeans) se encuentra en el menú Tools > Libraries. De ahí el resto es igual. Inténtalo y me avisas si te funciono.
hola buenas tardes, hise todo lo que exolicas en el tutorial pero no me marfca error en la siguiente linea
package PrimerJOGL;
import javax.swing.JFrame;
import com.jogamp.opengl.GLAutoDrawable;
import com.jogamp.opengl.GLEventListener;
import com.jogamp.opengl.GLProfile;
public class Renderer extends JFrame implements GLEventListener {
private static final long serialVersionUID = 1L;
public static void main(String[] args) {
// TODO Auto-generated method stub
aqui*public Renderer() aqui*{
super(“Primer aplicación JOGL”);
this.setSize(640, 480);
this.setLocationRelativeTo(null);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setResizable(false);
GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities caps = new GLCapabilities(profile);
GLCanvas canvas = new GLCanvas(caps);
y aqui*}
}
ahi te marque con * donde me marca el error (public y las 2 llaves)
Hola, prueba sacándo el método Renderer del main… Algo como
public static void main(String[] args) {// TODO Auto-generated method stub
}
public Renderer(){
super(“Primer aplicación JOGL”);
this.setSize(640, 480);
this.setLocationRelativeTo(null);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setResizable(false);
GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities caps = new GLCapabilities(profile);
GLCanvas canvas = new GLCanvas(caps);
}