Pruebas con JOGL-OpenGL

 Crear el Hola Mundo

  No se puede empezar a hacer algo en un nuevo programa o librería sin antes realizar el hola mundo. En caso deJOGL- OpenGL, en realidad no vamos a escribir algo, sino dibujar algo. En las paginas de tutoriales y demos sugieren empezar con el dibujo de un triángulo multicolor.

  JOGL-OpenGL funciona de forma  de una maquina de estados, es decir que es un proceso que pasar por una serie de etapas completando ciclos. Esto no pone una limitante, no podemos dibujar con JOGL-openGL cuando lo deseamos, sino que debemos de esperar al momento en que JOGL-OpenGL llega a la etapa o fase donde escribe en el buffer gráfico.

  Debido a lo anterior debemos de espera el momento oportuno para dar la indicación a JOGL-OpenGL a dibujar nuestro contenido. Para nuestra fortuna, OpenGL-JOGL nos proporciona una implementación de un listener (notificado de eventos) de las etapas que recorre OpenGL-JOGL.

Etapas o fases en JOGL

La primera etapa es inicio (init), en la cual se hace la inicialización de la libraría, realmente no se usa para el ejercicio del hola mundo y probablemente se usa para modificar la manera en como se debe de comportar OpenGL.

Las siguientes etapas son donde realmente se debe de realizar el el dibujado de los gráficos. La primera de ellas es  Display, es cuando OpenGL esta listo para dibujar en el buffer gráfico en la superficie o ventana asignada para este proposito. Le llamo buffer a aquel espacio en memoria destinado a almacenar la información gráfica que se mostrara en pantalla. Por esto, es en esta etapa cuando debemos de dibujar nuestro contenido.

La etapa de reshape (modificar), siguiere que es cuando OpenGL ha detectado alguna modificacion de la ventana o lugar donde imprime el buffer gráfico. Esta modificacion puede ser el cambio de tamaño de la ventana.

No voy entrar en detalles sobre OpenGL, ya que solo necesito que sirva para escribir un contenido grafico.

Setup

  Lo primero que se debe de hacer es ir al sitio de JOGL y descargar la version actual, archivo

(jogamp-all-platforms.7z)

Este archivo se abre con el programa 7-Zip, que se consigue gratuitamente. Dentro están contenidos librerías para diferentes sistemas operativos así como los jar que interactuán con al librerías. También existen una colección de jars que se les conoce como jars nativos. Estos jars contienen en su interior las librerías nativas para usar OpenGL.

En mi caso uso Windows y Netbeans. Después de bajar el archivo extraigo de este los archivos:

• gluegen-rt-natives-windows-amd64.jar
• jogl-all-natives-windows-amd64.jar
• jogl-all.jar
• gluegen-rt.jar
• gluegen.jar

Las dos primeras son jars nativos con las librerías dll para interactuar con OpenGL. El resto son librerías de java que se encargan de la interacción con los jars nativos y crean la estructura de objetos java para poder trabajar con los gráficos.

Ahora se debe de registrar las librerías en Netbeans. Se da click derecho al proyecto y se selecciona Properties.

Se selecciona la sección de Libraries, y se presiona Add Library 

Aqui se presiona Create

Se le da un nombre se presiona OK

En la siguiente ventana se añaden los jars antes mencionados

Presionamos OK en las siguientes ventanas y ya tenemos registrado JOGL-OpenCV en nuestro proyecto.

Se añade un jframe al proyecto, se puede usar el nombre  y el paquete que se quiera

Añadimos un Panel y un botón

En el código, depués de la clase principal añadimos la siguiente clase interna (no es buena practica, pero, esto es solo un demo). Se deben de arreglas los import o dependencias

  

 class SimpleScene implements GLEventListener {    
   private double theta = 0.0f; // rotational angle    
   @Override   
   public void init(GLAutoDrawable drawable) {    
   }   
   @Override   
   public void dispose(GLAutoDrawable drawable) {   
   }   
 //Este metodo se ejecuta cuando OpenGL esta listo para dibujar  
   @Override   
   public void display(GLAutoDrawable drawable) {   
    update(); //Se actualiza el angulo de dibujo del triangulo  
   render(drawable); // Se dibuja el triangulo  
   }   
 //Este metodo modifica el angulo del seno y coseno, que hacen que gire el triangulo  
   private void update() {   
   theta += 0.01;   
  }   
  private void render(GLAutoDrawable drawable) {   
 // El parametro drawable que recibimos, representa el espacio de dibujo listo para usarse  
 // de drawable se obtiene GL que la representacion de OpenGL, para despues indicar la version   
 //de OpenGL que se quiere usar, esto al usar un objeto especifico a la version.   
 //Se usa la dos por tratar de abarcar una version soportada por  
 //la mayoria de las tarjetas graficas, pero si se desea se puede usar alguna otra version  
   GL2 gl = drawable.getGL().getGL2();   
   gl.glClear(GL.GL_COLOR_BUFFER_BIT); // Se limpia el espacio de dibujo   
   gl.glLoadIdentity();     // Se resetea la matriz usada para la vista de los gráficos     
   // Calculo del seno y coseno para la animacion del triangulo   
    float sine = (float)Math.sin(theta);   
    float cosine = (float)Math.cos(theta);    
   // SE empieza a dibujar el triangulo   
   gl.glBegin(GL.GL_TRIANGLES);   
   gl.glColor3f(1, 0, 0); //Esto representa el color en estilo RGB, en esta caso rojo  
   gl.glVertex2d(-cosine, -cosine); //Esta es la coordenada de una orilla de triangulo  
   gl.glColor3f(0, 1, 0); //Esto representa el color en estilo RGB, en esta caso verde  
   gl.glVertex2f(0, cosine); //segunda orilla del triangulo  
   gl.glColor3f(0, 0, 1); //Esto representa el color en estilo RGB, en esta caso azul  
   gl.glVertex2f(sine, -sine); //tercera orilla del triangulo  
   gl.glEnd(); // se termina la animacion  
  }   
   @Override   
   public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {     
   }   
  }   

La clase anterior esta preparada para interactuar con las etapas de la máquina de estado de OpenGL, por eso se usa la interface GLEventListener.  Dentro del código hay documentación sobre lo que sucede en el código.

Se crea un método para la acción de pulsado del botón.

en el método que se creo se añade el siguiente código

 private void jButton1MouseClicked(java.awt.event.MouseEvent evt) {  
 //Se obtiene el tipo de OpenGL del equipo  
 GLProfile glp = GLProfile.getDefault();  
 //Se ven las caracteristicas del openGL del equipo  
 GLCapabilities caps = new GLCapabilities(glp);  
 //Se crea un espacio para que se pueda dibujar  
 javax.media.opengl.awt.GLCanvas canvas = new javax.media.opengl.awt.GLCanvas(caps);  
 //Se añade un listener para tener interaccion con lase tapas de la máquina de estado de OpenGL  
 canvas.addGLEventListener(new SimpleScene());  
 //Se crea una rutina o animador, que hace que el espacio de dibujo se integre en la máquina de estados de OpenGL  
 //Se puede especificar con este animador cada cuando se va a dibujar algo en el espacio, de esta manera se pueden realizar animaciones  
 //canvas –lugar de dibujo, 60- son los cuadros por segundo, true – ajustar temporizador  
 FPSAnimator animator = new FPSAnimator(canvas, 60, true);  
 //Se añade el espacio de dibujo OpenGL al panel  
 this.jPanel1.add(canvas);  
 //Se ajusta el espacio al tamaño del frame  
 canvas.setBounds(0,0,this.jPanel1.getWidth(),this.jPanel1.getHeight());  
 //Se inicia la rutina de animacion  
 animator.start();  
 }  

Cuando se copia el código Netbeans nos debe de ayudar a solucionar los problemas de referencias o imports.

Despues de solucionar los problemas, solo se debe de presionar shift+F6 y debemos de ver algo como lo siguiente, donde el triangulo esta girando: