Download Revista JavaOpenGL

CONTENIDO
JOGL (Java OpenGL)…………………………………………….. 3
Características…………………………………………………….. 4
Funcionamiento…………………………………………………… 5
Implementación…………………………………………………… 8
Clases y Métodos…………………………………………………. 11
Sistema de Coordenadas………………………………………….. 16
Primitivas……………………………………………………….. 17
Ejemplos…………………………………………………………. 18
Estructura de una Pirámide………………………………………. 19
Transformaciones………………………………………………… 20
Visibilidad de Superficies………………………………………… 22
Animaciones……………………………………………………… 26
Aplicaciones……………………………………………………… 27
Ejemplos de Código……………………………………………… 29
Apuntes Extras…………………………………………………… 34
Es una de las Tecnologías OpenSource iniciado por:
―the Game
Technology
Group‖
y
―Sun
Microsystems‖ en el año 2003 (JOGL
– JOAL - Jinput) con el objetivo de
proporcionar aceleración 3D por
hardware a aplicaciones Java.
Es una biblioteca que permite
programar OpenGL desde Java
M.Sc. Ing. Juan Pablo Luna
Felipez
Edad: 29
Docente de la Carrera Ing.
Informática (UNSXX).
Materia: Programación Gráfica
OpenGL es la interfaz software de hardware gráfico. (Motor 3D cuyas rutinas
están integradas en tarjetas graficas 3D
Desarrollado por Sillicon Graphics Inc (SGI), en pro de hacer un estándar en
la representación 3D gratuito y con código abierto (open source).
Consta de unas 120 funciones.
38
Diseñado de forma independiente del hardware por lo que es multiplataforma
No incluye comandos para gestionar ventanas, ni para capturar órdenes de
usuarios
3
 Puede combinarse con AWT y
SWING.
 Acceso a la mayoría de
características disponibles en C
(excepto llamadas a ventanas).
 Soporte de las librerías GLU y
GLUT.
 Soporte para animación, carga de
texturas, archivos y captura de
pantalla, etc.
 Trabaja como maquina de estados
(un estado permanece activado
hasta que se desactive).
 Sin soporte para sonido o
dispositivos de entrada(JOAL and
Jinput).
4
37
Diseño
Clases de JOGL
 Para trabajar con JOGL se
debe utilizar mínimamente
cinco clases:
GLCanvas
ó
GLPanel
 Utiliza la especificación JSR231
 Acceso total a la API
OpenGL 2.0
 Llama a la API OpenGL
gracias a la JNI JOGL
simplemente expone las
funciones de OpenGL, por
medio de métodos contenidos
en pocas clases (Wrapper).
 Desventaja: Al ser OpengL
procedural y de máquina de
estados es inconsistente con
la forma habitual de
programar en Java
GLEventListener
GLAutoDrawable
GL
Estas clases se encuentran en el
package javax.media.opengl
 Ventaja: Conversión de
código de aplicaciones C.
36
5
GLCanvas y
GLPanel
GLEventListener
 Interfaz que provee acceso
para realizar funciones de
dibujado, consta de 4
métodos:
init(GLAutoDrawable g)
 Se ejecuta la primera vez, aquí
se realizan tareas como la de
carga de texturas o la fijacion
de la perspectiva y la camara.
display(GLAutoDrawable g)
 Es aquí donde se hace el
dibujado
reshape(GLAutoDrawable
g, int x, int y, int ancho, int
alto)
 Este método es llamado
cuando la ventana cambia de
tamaño
displayChanged(GLAutoDr
awable g, boolean b1,
boolean b2)
 Se utiliza cuando se cambia de
dispositivo de despliegue
(gral. no utilizado)
 JOGL tiene dos clases
―containers‖ que permiten
realizar las funciones de
dibujado sobre ellos :
GLCanvas
GLJPanel
 Se puede utilizar cualquiera
 Es más veloz trabajar con
GLCanvas.
 GLPanel es para
compatibilidad con
componentes SWING.
En ambos se puede realizar el
dibujado a través de la interface
GLEventListener
6
35
GLAutoDrawable
 GLAutoDrawable es el elemento que permite acceder a las
funciones de dibujado, es por eso que forma parte de los
parámetros de la interfaz GLEventListener.
 Esta clase permite Obtener el contexto de dibujo a través de la
clase GL.
GL
 Es la clase principal que permite acceder directamente a las
funciones de OGL.
 Se obtiene a partir de la clase GLAutoDrawable
gl=g.getGL();
34
7
 1. Inicie NetBeans y entre en el menu Tools|Plugins.
 2. Presione el botón add y elija la opción Downloaded plugins
list y presione Install.
8
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
bQuit = true;
displayT.stop();
System.exit(0);
}
});
frame.setVisible(true);
//
frame.show();
canvas.requestFocus();
while( !bQuit ) {
canvas.display();
}
}
}
33
public void keyReleased(KeyEvent e) {
}
 3. Vaya a la pestaña de Settings y asegúrese de que el centro de
actualizaciones este habilitado.
public void keyTyped(KeyEvent e) {
}
}
JavaDia
class—La clase principal enlaza la clase JavaRenderer. El
código dibuja la escena en la GLCanvas.
import
import
import
import
javax.media.opengl.GLCanvas;
java.awt.Frame;
java.awt.event.WindowAdapter;
java.awt.event.WindowEvent;
public class JavaDia implements Runnable {
static Thread displayT = new Thread(new JavaDia());
static boolean bQuit = false;
public static void main(String[] args) {
displayT.start();
}
public void run() {
Frame frame = new Frame("Jogl 3d Shape/Rotation");
GLCanvas canvas = new GLCanvas();
canvas.addGLEventListener(new JavaRenderer());
frame.add(canvas);
frame.setSize(640, 480);
frame.setUndecorated(true);
int size = frame.getExtendedState();
size |= Frame.MAXIMIZED_BOTH;
frame.setExtendedState(size);
32
 4. Cambie a la pestaña de Available Plugins, busque OpenGL
y verifique que se encuentran todos los paquetes que se quieren
instalar.
 5. Finalice la instalación presionando Install.
9
public void displayChanged(GLAutoDrawable gLDrawable,
boolean modeChanged, boolean deviceChanged) {
}
public void init(GLAutoDrawable gLDrawable) {
final GL gl = gLDrawable.getGL();
gl.glShadeModel(GL.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(GL.GL_PERSPECTIVE_CORRECTION_HINT,
GL.GL_NICEST);
gLDrawable.addKeyListener(this);
}
public void reshape(GLAutoDrawable gLDrawable, int x,
int y, int width, int height) {
final GL gl = gLDrawable.getGL();
if(height <= 0) {
height = 1;
}
final float h = (float)width / (float)height;
gl.glMatrixMode(GL.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluPerspective(50.0f, h, 1.0, 1000.0);
gl.glMatrixMode(GL.GL_MODELVIEW);
gl.glLoadIdentity();
}
10
public void keyPressed(KeyEvent e) {
if(e.getKeyCode() == KeyEvent.VK_ESCAPE) {
JavaDia.bQuit = true;
JavaDia.displayT = null;
System.exit(0);
}
}
31
gl.glBegin(GL.GL_TRIANGLES);
// Front
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(1.0f,
-1.0f, 1.0f);
// Right Side Facing Front
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);
// Left Side Facing Front
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);
// Bottom
gl.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.glEnd();
rotateT += 0.2f;
}
30
Clase GLUT
Clase GLU
Constructor:
Constructor:
public GLUT()
public GLU()
Métodos:
Métodos:
gluNewQuadric()
public void glutWireSphere(double radius,
int slices, int stacks)
public void glutSolidSphere(double radius,
int slices, int stacks)
public void glutWireCone(double base,
double height, int slices, int stacks)
public void glutSolidCone(double base,
double height, int slices, int stacks)
public void
glutWireCylinder(double radius,
double height, int slices, int stacks)
public void
glutSolidCylinder(double radius,
double height, int slices, int stacks)
public void glutWireCube(float size)
public void glutSolidCube(float size)
public void
glutWireTorus(double innerRadius,
double outerRadius, int nsides, int rings)
public void
glutSolidTorus(double innerRadius,
double outerRadius, int nsides, int rings)
gluLookAt(double eyeX, double eyeY,
double eyeZ, double centerX, double
centerY, double centerZ, double upX,
double upY, double upZ)
gluCylinder(GLUquadric quad, double
base, double top, double height, int slices,
int stacks)
11
Para implementar esta interfaz se crea una clase para este propósito
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GL;
class CJogl implements GLEventListener
{
public void init(GLAutoDrawable g)
{
}
public void display(GLAutoDrawable g)
{
GL gl=g.getGL();
}
public void reshape(GLAutoDrawable g, int x, int y, int ancho,
int alto)
{
}
public void displayChanged(GLAutoDrawable g, boolean b1,
boolean b2)
{
Programación de una Pirámide 3D
Este programa dibuja una pirámide 3D mediante JOGL.
JavaRenderer
class — Esta clase usa GLAutoDrawable para generar la
escena.
import
import
import
import
import
import
javax.media.opengl.GL;
javax.media.opengl.GLEventListener;
javax.media.opengl.GLAutoDrawable;
javax.media.opengl.glu.GLU;
java.awt.event.KeyEvent;
java.awt.event.KeyListener;
public class JavaRenderer implements GLEventListener,
KeyListener {
private float rotateT = 0.0f;
private static final GLU glu = new GLU();
public void display(GLAutoDrawable gLDrawable) {
final GL gl = gLDrawable.getGL();
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(rotateT,
gl.glRotatef(rotateT,
gl.glRotatef(rotateT,
gl.glRotatef(rotateT,
}
}
12
1.0f,
0.0f,
0.0f,
0.0f,
29
0.0f,
1.0f,
0.0f,
1.0f,
0.0f);
0.0f);
1.0f);
0.0f);
GLCanvas se puede añadir como un componente en un JFrame
import javax.swing.JFrame;
import javax.media.opengl.GLCanvas;
class CVentana extends JFrame
{
CVentana()
{
this.setTitle("Programa JOGL");
this.setExtendedState(this.MAXIMIZED_BOTH);
this.setDefaultCloseOperation(this.EXIT_ON_CLOSE);
GLCanvas c=new GLCanvas();
c.addGLEventListener(new CJogl());
this.getContentPane().add(c);
this.show();
}
}
28
13
14
27
 Este programa dibuja una pirámide 3D mediante JOGL.
Una animación simplemente es un bucle de la función de dibujado
Con el objeto Animator conseguimos ese bucle y además conseguimos
el trato concurrente y la posibilidad de poder fijar la frecuencia de
redibujado.
Animator animator = null;
Animator = new
Animator(GLCanvas objeto);
Animator.start();
Animator.stop();
26
15
Establecer el tipo de Material
gl.glMaterialf(int, int, float);
 JOGL Maneja el sistema de cordenas como se muestra en la figura:
GLenum Face
GLenum pname
GL_FRONT
GL_DIFFUSE
Const
*params
(R,G,B,1.0)
GL_BACK
GL_AMBIENT
(R,G,B,1.0)
GL_FRONT_A
ND_BACK
GL_AMBIENT_AND_D
IFFUSE
GL_EMISION
GL_SPECULAR
GL_SHININESS
(R,G,B,1.0)
GLFloat
(R,G,B,1.0)
(R,G,B,1.0)
[0,128]
COLOR
gl.glMaterialfv(gl.GL_FRONT_AND_BACK*, gl.GL_AMBIENT,val*);
gl.glMaterialfv(gl.GL_FRONT_AND_BACK*, gl. GL_DIFUSSE,val*);
gl.glMaterialfv(gl.GL_FRONT_AND_BACK*, gl.
GL_AMBIENT_AND_DIFUSSE,val*);
gl.glMaterialfv(gl.GL_FRONT_AND_BACK*, gl.
GL_SPECULAR,val*);
*Se puede utilizar tambien GL_FRONT, GL_BACK
*val es un vector de tres componentes {R,G,B,A} que especifica el color.
(Es habitual que el comportamiento ante la luz difusa
y la ambiental sea el mismo)
16
25
LUCES (ILUMINACION)



Plana o FLAT
Suave o SMOOTH/GOURAUD
Iluminación PHONG
Punto
Línea
Triangulo
Cuadrado
Polígono, etc.
ILUMINACION FLAT
gl.glShadeModel(gl.GL_FLAT);
Iluminación SMOOTH
gl.glShadeModel(gl.GL_SMOOTH);
Materiales
 Se debe asociar un tipo de
material al poligono
“Una primitiva es simplemente la
interpretación de un conjunto de
vértices, dibujados de una forma
específica en pantalla”
Características de un material:
Reflexión Difusa (difusse)
Reflexión Espectacular (specular)
Reflexión Ambiental (ambient)
Coeficiente de Brillo (shininess)
Coeficiente de Emisión (emissión)
24
17
Modo Ortogonal
PASOS PARA USAR LUCES
gl.glOrtho(xmin,xmax,ymin,ymax,zm 1) Activar el uso de luces
in,zmax);
gl.glEnable(gl.GL_LIGHTING);
2) Posicionar la camara
2) Definir las carácterísticas de cada
glu.gluLookAt(posx,posy,posz,ojox,o luz
joy,ojoz,vx,vy,vz);
gl.glLigthfv(…);
3) Definir las caracteristicas de los
materiales de los objetos
gl.glMaterialfv(…);
4) Activar luces
gl.glEnable(gl.GL_LIGHTn);
LUCES
Permite dar mayor realismo a la
escena
Esiten tres tipos de luces:
18
23
1) Activar el ocultamiento de
objetos
gl.glEnable(gl.GL_DEPTH_TES
T);
MANEJO DE LA CAMARA
Permite mover nuestro punto de
vista en toda aplicación grafica
para mirar al punto que se desee
2) Indicar que se renderize las
partes visibles
gl.glClear(gl.GL_COLOR_BUFF
ER_BIT|gl.GL_DEPTH_BUFFE
R_BIT);
Establecer el modo de vista
gl.glBegin(primitiva);
/* definir vertices que conforman la primitiva */
glEnd();
Ejemplo
gl.glBegin(gl.GL_TRIANGLES);
{
gl.glColor3f(1f,0f,0f);
gl.glVertex(-1f,0f,0f);
gl.glColor3f(0f,1f,0f);
gl.glVertex(1f,0f,0f);
gl.glColor3f(0f,0f,1f);
gl.glVertex(0f,1f,0f);
}
glEnd();
Modo Perspectiva
glu.gluPerspective(angulo,aspecto*
,vistaCercana,vistaLejana)
*aspecto=Relación ancho alto
3) Desactivar el ocultamiento de
objetos
gl.glDisable(gl.GL_DEPTH_TES
T);
22
19
PUNTOS
gl.glPointSize(5.0f);
 TRASLACION
gl.glTraslatef(float,float,float);
 ROTACIÓN
gl.glRotatef(float,
float,float,float);
 ESCALACIÓN
gl.glScalef(float,float,float);
Otras…
LINEAS
GLLINES
Líneas sueltas
GL_LINE_STRIP
Líneas conectadas
GL_LINE_LOOP
Líneas conectadas mas la última con
la primera
TRIÁNGULOS
GL_TRIANGLES
Dibuja un triángulo
GL_TRIANGLE_STRIP
Dibuja varios triángulos conectados
CUADRADOS
GL_QUADS
Dibuja cuadrados
GL_QUAD_STRIP
Dibuja cuadrados conectados
COLORES
gl.glColor3f(r,g,b);
Establece un color con el sistema
RBG
Rellena con el último color activo
gl.glShadelModel(GL_SMOOTH)
Rellena en degrado con los color
definidos para cada vértice
OCULTAR OBJETOS NO
VISIBLES
gl.glEnable(gl.GL_DEPTH_TEST)
;
Activa el ocultamiento de objetos
gl.glDisable(gl.GL_DEPTH_TEST
);
Desactiva el ocultamiento de objetos
BORRAR FONDO
gl.glClear(gl.GL_COLOR_BUFFE
R_BIT)
Borra con el color establecido en el
buffer con gl.glClearColor
gl.glClear(gl.GL_COLOR_BUFFE
R_BIT|gl.GL_DEPTH_BUFFER_
BIT);
Borra con el color establecido en el
buffer con gl.glClearColor y las
partes ocultas
RELLENADO DE POLIGONOS
gl.glShadelModel(GL_FLAT)
20
21