| Java OpenGL ( JSR-231 ) | |
|---|---|
| Captura de pantalla que demuestra la refracción en tiempo real usando JOGL en Mac OS X | |
| Tipo de | biblioteca |
| Desarrollador | Comunidad JogAmp |
| Escrito en | Java |
| Sistema operativo | multiplataforma |
| plataforma de hardware | máquina virtual de Java |
| ultima versión | 2.3.2 ( 10 de octubre de 2015 ) |
| Versión de prueba | 2.4.0 |
| Licencia | Licencia BSD de 2 cláusulas |
| Sitio web | jogamp.org/jogl/w… ( inglés) |
Java OpenGL (JOGL) es una biblioteca que enlaza directamente las funciones de OpenGL con el lenguaje de programación Java . Es la implementación de referencia de la especificación JSR-231 (Java Bindings to OpenGL). Destacado por la comunidad independiente opengl.org [1] (ver Enlaces de lenguaje de programación a OpenGL ). La biblioteca fue desarrollada originalmente por Kenneth Bradley Russell y Christopher John Kline y más tarde por Game Technology Group en Sun Microsystems . Actualmente es un proyecto independiente de código abierto.
JOGL proporciona al programador acceso a todas las características de la especificación OpenGL API 2.0 ya todas las extensiones de OpenGL de los principales proveedores [2] . JOGL también brinda acceso a los dos complementos principales de OpenGL: OpenGL Helper Library (GLU) y OpenGL Developer Toolkit (GLUT) (con la excepción de las características relacionadas con el sistema de ventanas de GLUT, ya que Java tiene su propia multiplataforma). sistema de ventanas de alto nivel AWT y Swing ).
La biblioteca JOGL también contiene varias clases adicionales que no se describen en la especificación JSR-231, que sirven para la conveniencia de procesar datos para comandos OpenGL y relacionados con las características del lenguaje Java (como datos de E/S de archivos OpenGL, preparación texturas, preparación de arreglos de datos para OpenGL).
JOGL implementa el acceso a la API de bajo nivel de la biblioteca OpenGL escrita en C a través de la interfaz JNI . Para que JOGL funcione correctamente, se supone que el entorno de software y hardware es compatible con OpenGL.
JOGL se diferencia de otros contenedores de OpenGL en que, en esencia, simplemente proporciona al programador la capacidad de trabajar con la API de OpenGL accediendo a los comandos de OpenGL a través de llamadas a los métodos correspondientes con los tipos de argumentos de desarrollador de Java habituales colocados en varias clases, en lugar de encapsulando la funcionalidad de OpenGL en algunos o en un paradigma orientado a objetos. De hecho, la mayor parte del código JOGL interno se genera automáticamente a partir de archivos de encabezado C mediante una utilidad especial , Gluegen , especialmente escrita para facilitar la creación de JOGL.
Esta solución tiene sus ventajas y desventajas. Las características de la arquitectura de OpenGL, que, por un lado, es un autómata discreto y, por otro, una API de procedimiento, no se corresponde con el enfoque de programación en Java. Sin embargo, la asignación directa de la API de OpenGL a muchos métodos de Java hace que sea mucho más fácil trasladar el código de OpenGL ya escrito en C a Java. El bajo nivel de abstracción de JOGL hace posible construir programas que son bastante eficientes en términos de velocidad de ejecución, pero al mismo tiempo complican el proceso de programación en comparación con un mayor nivel de abstracción y librerías contenedoras verdaderamente orientadas a objetos sobre OpenGL para Java. (por ejemplo, como Java3D ). Además, dado que una parte significativa del código interno se genera automáticamente, los desarrolladores pueden agregar rápidamente a JOGL cualquier cambio en OpenGL (como el desarrollo de bibliotecas o la aparición de nuevas extensiones).
Según los desarrolladores, en 2007 JOGL admite el acceso completo a todas las funciones de la especificación OpenGL 2.0.
La última versión estable de JOGL versión 1.1.0 es la implementación de referencia de JSR - 231 (Java Bindings for OpenGL).
La próxima versión 1.1.1 tendrá que funcionar con el complemento GLU NURBS (dibujar líneas y superficies curvas a través de la API GLU estándar). Hay planes para lanzar una especificación JSR-231 1.1.1 revisada y agregar puntos de entrada relacionados con NURBS a la API JSR-231. La versión 2.0.2 brinda acceso completo a las versiones 1.0 a 4.3 de la API de OpenGL, así como a las especificaciones ES 1, ES 2 y ES 3 y casi todas las extensiones.
La especificación JSR-231: enlace de Java (TM) a la API de OpenGL(R), enlace de Java(TM) a la API de OpenGL(R ) define un modelo para vincular una implementación nativa de la biblioteca OpenGL (una implementación para un sistema operativo) al lenguaje de programación Java.
La especificación JSR-231 define dos paquetes:
(En JOGL, ambos paquetes se colocan en la biblioteca en un archivo jar jogl.jar )
A partir de la versión 1.6 de Java Standard Edition , la API 2D de Java y OpenGL pueden comunicarse a través de JOGL:
El programa muestra un ejemplo del dibujo más simple de un tetraedro usando JOGL.
Clase JavaRenderer : se utiliza GLAutoDrawablepara dibujar una escena en 3D.
importar com.jogamp.opengl.GL ; importar com.jogamp.opengl.GL2 ; importar com.jogamp.opengl.GLEventListener ; importar com.jogamp.opengl.GLAutoDrawable ; importar com.jogamp.opengl.glu.GLU ; la clase pública JavaRenderer implementa GLEventListener { private float rotaryT = 0.0f ; GLU final estática privada glu = nueva GLU (); visualización vacía pública ( GLAutoDrawable gLDrawable ) { final GL2 gl = gLDrawable . obtener GL (). obtenerGL2 (); gl . glClear ( GL . GL_COLOR_BUFFER_BIT ); gl . glClear ( GL . GL_DEPTH_BUFFER_BIT ); gl . glLoadIdentity (); gl . glTranslatef ( 0.0f , 0.0f , - 5.0f ); gl . glRotatef ( rotarT , 1.0f , 0.0f , 0.0f ); gl . glRotatef ( rotarT , 0.0f , 1.0f , 0.0f ); gl . glRotatef ( rotarT , 0.0f , 0.0f , 1.0f ); gl . glRotatef ( rotarT , 0.0f , 1.0f , 0.0f ); gl . glBegin ( GL2 . GL_TRIANGLES ); // Gl frontal . glColor3f ( 0.0f , 1.0f , 1.0f ); gl . glVertex3f ( 0.0f , 1.0f , 0.0f ); gl . glColor3f ( 0.0f , 0.0f , 1.0f ); gl . glVertex3f ( - 1.0f , - 1.0f , 1.0f ); gl . glColor3f ( 0.0f , 0.0f , 0.0f ); gl . glVertex3f ( 1.0f , - 1.0f , 1.0f ); // Lado derecho frente al frente gl . glColor3f ( 0.0f , 1.0f , 1.0f ); gl . glVertex3f ( 0.0f , 1.0f , 0.0f ); gl . glColor3f ( 0.0f , 0.0f , 1.0f ); gl . glVertex3f ( 1.0f , - 1.0f , 1.0f ); gl . glColor3f ( 0.0f , 0.0f , 0.0f ); gl . glVertex3f ( 0.0f , - 1.0f , - 1.0f ); // Lado izquierdo frente al frente gl . glColor3f ( 0.0f , 1.0f , 1.0f ); gl . glVertex3f ( 0.0f , 1.0f , 0.0f ); gl . glColor3f ( 0.0f , 0.0f , 1.0f ); gl . glVertex3f ( 0.0f , - 1.0f , - 1.0f ); gl . glColor3f ( 0.0f , 0.0f , 0.0f ); gl . glVertex3f ( - 1.0f , - 1.0f , 1.0f ); // Gl inferior . glColor3f ( 0.0f , 0.0f , 0.0f ); gl . glVertex3f ( - 1.0f , - 1.0f , 1.0f ); gl . glColor3f ( 0.1f , 0.1f , 0.1f ); gl . glVertex3f ( 1.0f , - 1.0f , 1.0f ); gl . glColor3f ( 0.2f , 0.2f , 0.2f ); gl . glVertex3f ( 0.0f , - 1.0f , - 1.0f ); gl . cañada (); rotarT += 0.2f ; } public void init ( GLAutoDrawable gLDrawable ) { final GL2 gl = gLDrawable . obtener GL (). obtenerGL2 (); gl . glShadeModel ( GL2 . GL_SMOOTH ); gl . glClearColor ( 0.0f , 0.0f , 0.0f , 0.0f ); gl . glClearDepth ( 1.0f ); gl . glEnable ( GL . GL_DEPTH_TEST ); gl . glDepthFunc ( GL . GL_LEQUAL ); gl . glHint ( GL2 . GL_PERSPECTIVE_CORRECTION_HINT , GL . GL_NICEST ); } cambio de forma de vacío público ( GLAutoDrawable gLDrawable , int x , int y , int ancho , int alto ) { final GL2 gl = gLDrawable . obtener GL (). obtenerGL2 (); si ( altura <= 0 ) { altura = 1 ; } final float h = ( float ) ancho / ( float ) altura ; gl . glModoMatriz ( GL2 . GL_PROJECTION ); gl . glLoadIdentity (); pegamento _ gluPerspectiva ( 50.0f , h , 1.0 , 1000.0 ); gl . glModoMatriz ( GL2 . GL_MODELVIEW ); gl . glLoadIdentity (); } eliminación de vacío público ( GLAutoDrawable arg0 ) { } }JavaDiaclass —La clase principal responsable de llamar a execute JavaRenderer. El código dibuja una escena 3D en GLCanvas'e.
importar java.awt.Frame ; importar java.awt.event.KeyEvent ; importar java.awt.event.KeyListener ; importar java.awt.event.WindowAdapter ; importar java.awt.event.WindowEvent ; importar com.jogamp.opengl.awt.GLCanvas ; la clase pública JavaDia implementa Runnable , KeyListener { subproceso estático privado displayT = nuevo subproceso ( nuevo JavaDia ()); privado estático booleano bSalir = falso ; public static void main ( String [] args ) { displayT . inicio (); } public void run () { Frame frame = new Frame ( "Jogl 3D Shape/Rotation" ); lienzo GLCanvas = nuevo GLCanvas (); tamaño int = marco . getExtendedState (); lona _ addGLEventListener ( nuevo JavaRenderer ()); marco _ añadir ( lienzo ); marco _ establecer Sin decorar ( verdadero ); tamaño |= Marco . MAXIMIZADO_AMBOS ; marco _ setExtendedState ( tamaño ); lona _ addKeyListener ( esto ); marco _ paquete (); marco _ setLocationRelativeTo ( nulo ); marco _ addWindowListener ( new WindowAdapter () { public void windowClosing ( WindowEvent e ) { bQuit = true ; System . exit ( 0 ); } }); marco _ setVisible ( verdadero ); lona _ solicitud de enfoque (); while ( ! bSalir ) { lienzo . mostrar (); } } public void keyPressed ( KeyEvent e ) { if ( e . getKeyCode () == KeyEvent . VK_ESCAPE ) { displayT = null ; b Salir = verdadero ; sistema _ salir ( 0 ); } } Public void keyReleased ( KeyEvent e ) { } keyTyped vacío público ( KeyEvent e ) { } }La entrega de JOGL incluye las siguientes partes:
Cada parte de la biblioteca JOGL viene en un archivo zip separado. El nombre del archivo zip refleja el nombre de la parte, información sobre la versión de JOGL e información sobre la plataforma de hardware y software si la parte contiene componentes nativos.