Unidad Acadmica

Navojoa

Tecnicas de graficacion

Actividad 11

Jesus Ramon Lopez Sanches

Luis Antonio Domnguez Gutirrez

Ingeniera en Software

16 de noviembre de 2016, Navojoa, Sonora

Algoritmos sobre movimientos en 3D.

Cubo de Rubik en JAVA

Hola amigos de "Buenas Intenciones", en esta le explicare como hacer el cubo de Rubik utilizando
las librera de OpenGL, que es una librera para grficos por computadora un poco ms avanzada
donde utilizaremos cdigo en java 3D, con textura, movimientos de cmara, traslacin, rotacin.
Primero veamos que es OpenGL proporciona una biblioteca bsica de funciones para especificar
primitivas grficas, atributos, transformaciones geomtricas, transformaciones de visualizacin y
muchas otras operaciones.
Los nombres de las funciones de la biblioteca bsica de OpenGL (tambin llamada de biblioteca
del ncleo
De OpenGL) utilizan como prefijo g l , y cada palabra que forma parte del nombre de una funcin
tiene su
Primera letra en mayscula. Los siguientes ejemplos ilustran este convenio de denominacin.
glBegin,
glClear,
glCopyPixels,
glPolygonMode
Bueno sin ms que decir empezamos analizando el cdigo lnea por lnea.
NOTA: Todo el cdigo es en una sola clase y est dividido en fragmentos para facilitar el
entendimiento.
//Archivo: Rubik.java
//Autor: Ivan Gallardo
import com.sun.opengl.util.Animator;
import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCanvas;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.glu.GLU;
import javax.swing.JFrame;
import com.sun.opengl.util.GLUT;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.File;
import com.sun.opengl.util.texture.Texture;
import com.sun.opengl.util.texture.TextureIO;
import java.io.IOException;
public class Rubik extends JFrame implements KeyListener{
static GL gl;
static GLU glu;
static GLUT glut;
static GLCanvas canvas;

private static float rotarX=0;

private static float rotarY=0;
private static float rotarZ=0;
private static float trasladaX=0;
private static float trasladaY=0;
private static float trasladaZ=0;
private Texture cara1, cara2,cara3,cara4, cara5,cara6;
private static float EscaX=1.0f;
private static float EscaY=1.0f;
private static float EscaZ=1.0f;
private static float EscaXm=1.0f;
private static float EscaYm=1.0f;
private static float EscaZm=1.0f;
static float rojo=0.0f;
static float verde=0.0f;
static float azul=0.0f;
Bueno de la lnea de comando 3 a la 16 son las libreras necesarias para los diferentes mtodos
que
utilizaremos en nuestro programa que en Netbeans se originan automticamente cuando
insertamos una sentencia que las necesite asi que con eso no tendremos mayor problema. Bien en
nuestra lnea 18 est el nombre de nuestra clase con la extensin de JFrame para nuestro frame
de la clase tenemos implementado KeyListener para poder utilizar nuestro teclado y asignarle
funciones. De la lnea 19 a 38 son nuestras variables que ocuparemos en todo nuestro programa
ya ir mencionando cada una de ellas conforme vayamos haciendo uso de ellas.
public Rubik(){
setSize(700, 600);
setTitle("Cubo De Rubik");
setResizable(true);
GraphicListener listener = new GraphicListener();
canvas = new GLCanvas();
gl = canvas.getGL();
glu = new GLU();
glut = new GLUT();
canvas.addGLEventListener(listener);
getContentPane().add(canvas);
Animator animator = new Animator(canvas);
animator.start();
addKeyListener(this);
}
Bien continuando con nuestro programa en la siguiente lnea creamos nuestro constructor con el
nombre de nuestra clase que es como se identifica. en la lnea 2 asignamos el tamao de la
ventana donde mostraremos nuestra figura, en la lnea 3 el ttulo de la ventana en este caso es
"Cubo de Rubik", la sentencia setResizable puede ser false o true como se muestra en nuestro
cdigo y esto sirve para los que no sabemos para maximizar o o minimizar el tamao de la
ventana, en la lnea 5 invocamos a la clase GraphicListener con el nombre listener para inicializar
o convocar la clase. En la lnea 6 utilizaremos nuestra primer variable asignada en el fragmento
anterior (lnea 22) que es GLCanvas con el nombre canvas para poder utilizar todos los mtodos
que esa clase contiene, para que nos sirve el canvas para visualizar bsicamente nuestras figura
de OpenGL en una forma animada, de las lnea 7 a la 9 Utilizaremos las otras 3 variables de
OpenGL donde en la variable gl asignamos la clase canvas con sus mtodos, las variables glu y
glut son variables que contienen una clase de figuras predefinidas que veremos ms adelante, en
las tres ltimas lneas de cdigo lo nico que se hace es invocar la clase animator e introducir
dentro de ella la clase canvas para dar la animacin y procedemos a darle inicio con star(), la
ultima es para nuestro teclado y las teclas que seran asignadas mas adelante con su respectiva
funcin.

public static void main(String args[]){

Rubik r = new Rubik();
r.setVisible(true);
r.setDefaultCloseOperation(EXIT_ON_CLOSE);
r.setLocationRelativeTo(null);
}
Se podra decir que es la parte ms importante del programa porque es donde esta
nuestro main, que es el mtodo que inicializa a nuestra clase completa y hace que nuestro
programa corra.
public class GraphicListener implements GLEventListener{
public void display(GLAutoDrawable arg0) {
gl = arg0.getGL();
gl.glClear(GL.GL_COLOR_BUFFER_BIT|GL.GL_DEPTH_BUFFER_BIT);
gl.glMatrixMode(GL.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluPerspective(50, 2, 0.1, 30);
gl.glMatrixMode(GL.GL_MODELVIEW);
gl.glDepthFunc(GL.GL_LEQUAL);
gl.glEnable(GL.GL_DEPTH_TEST);
gl.glClearDepth(1.0);
gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE,
gl.GL_DECAL);
gl.glLoadIdentity();
glu.gluLookAt(0.1 + trasladaX, .1 + trasladaY, .5 +
trasladaZ, 0.5 + trasladaX,0, -5.5 + trasladaZ, 0.0, 1.0, 0.0);
En esta parte del cdigo iniciamos una nueva clase que se llama GraphicListener y le
implementamos la librera de OpenGL con eventos, enseguida creamos un mtodo
llamado display que es como su nombre lo dice nos permite mostrar nuestro cubo, en la siguiente
lnea utilizamos nuestra variable gl y le asignamos el argumento arg0 con la librera de OpenGL, en
las prximas lneas utilizamos las librera de OpenGL para crear la perspectiva, proyeccin, textura,
traslacin y las inicializamos como se muestran.
cara1.enable();
cara1.bind();
gl.glScalef(EscaX,EscaY,EscaZ);
gl.glScalef(EscaXm,EscaYm,EscaZm);
gl.glRotatef(rotarX, 1f, 1f, 0f);
gl.glRotatef(rotarY, 0f, 1f, 1f);
gl.glRotatef(rotarZ, 0f, 0f, 1f);
gl.glBegin(gl.GL_QUADS);
gl.glTexCoord2f(1, 1);
gl.glVertex3f(0, 0, 0);
gl.glTexCoord2f(0, 1);
gl.glVertex3f(0.2f, 0f, 0);
gl.glTexCoord2f(0, 0);
gl.glVertex3f(.2f, .2f, 0);
gl.glTexCoord2f(1, 0);
gl.glVertex3f(0f, .2f, 0);
gl.glEnd();
cara1.disable();
Atencin en esta parte del cdigo ya que es una de las partes ms importantes de nuestro
programa, bien en la lnea 1 utilizamos nuestra primer variable de tipo textura llamada cara1 con el
mtodo permitir mostrar la primer cara del cubo, en la lnea 2 obligamos a nuestro programa a
mostrar cara1, de la lnea 3 a la 7 utilizamos las librera OpenGL de exhalacin y rotacin cada
uno de estos mtodos tiene tres valores booleano dentro del primer mtodo que es el glScalef(),
colocamos nuestras variables de escalacion positivas y en la lnea siguiente mismo mtodo pero

con variables negativas (en la parte de las teclas vern porque positivo(+) y negativo(-)), el
mtodo glRotatef() al igual que el glSalef() contiene valores booleanos y en el primero tenemos
valores positivos y en el segundo tenemos valores negativos. En la lnea de 8 utilizamos la librera
de primitivas de OpenGL del cuadrado para formar nuestra cara principal sea la cara 1, de la lnea
de cdigo 9 a la 16 ponemos la ubicacin de los puntos de coordenadas 3D y los vrtices, por
ltimo en la 17 y 18 terminamos nuestro muestre de la cara1 y deshabilitamos nuestra cara 1 para
poder activar las 5 caras restantes utilizando el mismo cdigo.
public void init(GLAutoDrawable arg0){
try {
cara1 = TextureIO.newTexture(new
cara2 = TextureIO.newTexture(new
cara3 = TextureIO.newTexture(new
cara4 = TextureIO.newTexture(new
cara5 = TextureIO.newTexture(new
cara6 = TextureIO.newTexture(new
} catch (IOException e) {
System.exit(1);
}

File("Rubik.jpg"), true);
File("Rubik1.jpg"), true);
File("Rubik2.jpg"), true);
File("Rubik3.jpg"), true);
File("Rubik4.jpg"), true);
File("Rubik5.jpg"), true);

}
En este mtodo es donde mandaremos a traer a nuestra textura como podemos observar son 6
caras lo que quiere decir que para cada cara necesitamos una textura y finalizamos con un true
para que la muestre.
public void keyPressed(KeyEvent arg0){
if(arg0.getKeyCode()==KeyEvent.VK_ESCAPE){
rotarX=0;
rotarY=0;
rotarZ=0;
trasladaX=0;
trasladaY=0;
trasladaZ=0;
EscaX=1.0f;
EscaY=1.0f;
EscaZ=1.0f;
EscaXm=1.0f;
EscaYm=1.0f;
EscaZm=1.0f;
rojo=0.0f;
verde=0.0f;
azul=0.0f;
}
if(arg0.getKeyCode()==KeyEvent.VK_X){
rotarX+=1.0f;
}
if(arg0.getKeyCode()==KeyEvent.VK_A){
rotarX-=1.0f;
}
if(arg0.getKeyCode()==KeyEvent.VK_Y){
rotarY+=1.0f;
}
if(arg0.getKeyCode()==KeyEvent.VK_B){
rotarY-=1.0f;

}
if(arg0.getKeyCode()==KeyEvent.VK_Z){
rotarZ+=1.0f;
}
if(arg0.getKeyCode()==KeyEvent.VK_C){
rotarZ-=1.0f;
}
if(arg0.getKeyCode()==KeyEvent.VK_RIGHT){
trasladaX+=.10f;
}

if(arg0.getKeyCode()==KeyEvent.VK_LEFT){
trasladaX-=.10f;
if(arg0.getKeyCode()==KeyEvent.VK_UP){
trasladaY+=.10f;

if(arg0.getKeyCode()==KeyEvent.VK_DOWN){
trasladaY-=.10f;
}
if(arg0.getKeyCode()==KeyEvent.VK_1){
trasladaZ+=.1;
}
if(arg0.getKeyCode()==KeyEvent.VK_2){
trasladaZ-=.10f;
}
if(arg0.getKeyCode()==KeyEvent.VK_3){
rotarY+=1.0;
}
if(arg0.getKeyCode()==KeyEvent.VK_4){
rotarY-=1.0;
}
else if (arg0.getKeyCode()== KeyEvent.VK_I){
EscaX +=0.1f;
}
else if (arg0.getKeyCode()== KeyEvent.VK_O){
EscaY +=0.1f;
}
else if (arg0.getKeyCode()== KeyEvent.VK_P){
EscaZ +=0.1f;
}
else if (arg0.getKeyCode()== KeyEvent.VK_J){
EscaXm -=0.1f;
}
else if (arg0.getKeyCode()== KeyEvent.VK_K){
EscaYm -=0.1f;
}
else if (arg0.getKeyCode()== KeyEvent.VK_L){
EscaZm -=0.1f;

}
else if (arg0.getKeyCode()== KeyEvent.VK_E){
rojo +=0.1f;
}
else if (arg0.getKeyCode()== KeyEvent.VK_R){
verde +=0.1f;
}
else if (arg0.getKeyCode()== KeyEvent.VK_T){
azul +=0.1f;
}

public void keyReleased(KeyEvent arg0){}

public void keyTyped(KeyEvent arg0){}
Estamos en la ltima parte de nuestro programa es la parte donde asignamos a cada tecla una
funcin o una variable con un valor ya sea en aumento o disminucin para darle valores a los
mtodos donde fueron colocadas la nica q sirve con un reset es la tecla escape que esa es
restaurar
todos
los
valores
de
las
variables
como
estaban
al
inicio.
Bueno sin ms que decir aqu esta una imagen de nuestro cubo y ms abajo el cdigo java del
programa espero y les haya servido suerte.