Upload
dinhtram
View
234
Download
0
Embed Size (px)
Citation preview
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
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.
Diseñado de forma independiente del hardware por lo que es multiplataforma
No incluye comandos para gestionar ventanas, ni para capturar órdenes de
usuarios
Es una de las Tecnologías Open-
Source 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
3 38
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).
37 4
Diseño
Utiliza la especificación JSR-
231
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
Ventaja: Conversión de
código de aplicaciones C.
Clases de JOGL
Para trabajar con JOGL se
debe utilizar mínimamente
cinco clases:
GLCanvas
ó
GLPanel
GLEventListener
GLAutoDrawable
GL
Estas clases se encuentran en el
package javax.media.opengl
5 36
GLCanvas y
GLPanel
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
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)
35 6
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();
7 34
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.
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 8
3. Vaya a la pestaña de Settings y asegúrese de que el centro de
actualizaciones este habilitado.
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.
public void keyReleased(KeyEvent e) {
}
public void keyTyped(KeyEvent e) {
}
}
JavaDia class—La clase principal enlaza la clase JavaRenderer. El
código dibuja la escena en la GLCanvas.
import javax.media.opengl.GLCanvas;
import java.awt.Frame;
import java.awt.event.WindowAdapter;
import 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);
9 32
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();
}
public void keyPressed(KeyEvent e) {
if(e.getKeyCode() == KeyEvent.VK_ESCAPE) {
JavaDia.bQuit = true;
JavaDia.displayT = null;
System.exit(0);
}
}
31 10
Clase GLUT
Constructor:
public GLUT()
Métodos:
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)
Clase GLU
Constructor:
public GLU()
Métodos:
gluNewQuadric()
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)
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;
}
11 30
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 javax.media.opengl.GL;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.glu.GLU;
import java.awt.event.KeyEvent;
import 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, 1.0f, 0.0f, 0.0f);
gl.glRotatef(rotateT, 0.0f, 1.0f, 0.0f);
gl.glRotatef(rotateT, 0.0f, 0.0f, 1.0f);
gl.glRotatef(rotateT, 0.0f, 1.0f, 0.0f);
29 12
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();
}
}
13 28
27 14
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();
15 26
GLenum Face GLenum pname Const GLFloat
*params
GL_FRONT GL_DIFFUSE (R,G,B,1.0)
GL_BACK GL_AMBIENT (R,G,B,1.0)
GL_FRONT_A
ND_BACK
GL_AMBIENT_AND_D
IFFUSE
(R,G,B,1.0)
GL_EMISION (R,G,B,1.0)
GL_SPECULAR (R,G,B,1.0)
GL_SHININESS [0,128]
JOGL Maneja el sistema de cordenas como se muestra en la figura:
Establecer el tipo de Material
gl.glMaterialf(int, int, float);
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)
25 16
Punto
Línea
Triangulo
Cuadrado
Polígono, etc.
“Una primitiva es simplemente la
interpretación de un conjunto de
vértices, dibujados de una forma
específica en pantalla”
LUCES (ILUMINACION)
Plana o FLAT
Suave o SMOOTH/GOURAUD
Iluminación PHONG
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
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)
17 24
Modo Ortogonal
gl.glOrtho(xmin,xmax,ymin,ymax,zm
in,zmax);
2) Posicionar la camara
glu.gluLookAt(posx,posy,posz,ojox,o
joy,ojoz,vx,vy,vz);
LUCES
Permite dar mayor realismo a la
escena
Esiten tres tipos de luces:
PASOS PARA USAR LUCES
1) Activar el uso de luces
gl.glEnable(gl.GL_LIGHTING);
2) Definir las carácterísticas de cada
luz
gl.glLigthfv(…);
3) Definir las caracteristicas de los
materiales de los objetos
gl.glMaterialfv(…);
4) Activar luces
gl.glEnable(gl.GL_LIGHTn);
23 18
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();
1) Activar el ocultamiento de
objetos
gl.glEnable(gl.GL_DEPTH_TES
T);
2) Indicar que se renderize las
partes visibles
gl.glClear(gl.GL_COLOR_BUFF
ER_BIT|gl.GL_DEPTH_BUFFE
R_BIT);
3) Desactivar el ocultamiento de
objetos
gl.glDisable(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
Establecer el modo de vista
Modo Perspectiva
glu.gluPerspective(angulo,aspecto*
,vistaCercana,vistaLejana)
*aspecto=Relación ancho alto
19 22
TRASLACION
gl.glTraslatef(float,float,float); ROTACIÓN
gl.glRotatef(float,
float,float,float); ESCALACIÓN
gl.glScalef(float,float,float);
Otras…
PUNTOS gl.glPointSize(5.0f);
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
RELLENADO DE POLIGONOS gl.glShadelModel(GL_FLAT)
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
21 20