Introducción a Java3D (página 3)

Algoritmo 2.1. Procedimiento para desarrollar un programa en Java3D.

Aunque no profundiza demasiado, este algoritmo sí refleja el concepto fundamental de la programación en Java3D: lo más importante consiste en la creación de las distintas ramas del grafo de escena.

2.5 Sistema De Coordenadas.

Los sistemas de coordenadas en Java3D son, por defecto, "diestros", de tal forma que la parte positiva del eje de ordenadas es el sentido ascendente de la gravedad, la parte positiva del eje de abscisas es horizontal hacia la derecha y la parte positiva del eje Z está dirigido hacia el observador.

La unidad utilizada por default son los metros. En la Figura 2.1 se puede ver gráficamente esta distribución.

Figura 2.2. Sistema de coordenadas Java3D.

2.5.1 Coordenadas De Alta Resolución.

La representación de las coordenadas con valores en punto flotante de doble precisión, de simple precisión o incluso valores de menor precisión es suficiente para representar y mostrar escenas en tres dimensiones de gran calidad. Si nos alejamos doscientos kilómetros desde el origen de coordenadas utilizando una precisión sencilla de punto flotante, los puntos representables aparecen de alguna forma discretizados. Si lo que se pretende es llegar a distancias muy pequeñas, muy cerca del origen, aparece el mismo problema. Las coordenadas de alta resolución de Java3D constan de 3 números de 256 bits de punto fijo, uno para cada eje. El punto fijo se encuentra en el bit 128 y el valor 1.0 se corresponde exactamente con un metro. Este sistema de coordenadas es suficiente para describir un universo tan enorme como varios cientos de billones de años luz o como para definir objetos tan pequeños como un protón.

En la Tabla 2.2 se representan cuántos bits son necesarios por encima o por debajo del punto fijo para representar el rango que nos interese.

Tabla 2.2. Escalas de las coordenadas de alta resolución

Los números de punto fijo de 256 bits proporcionan también la ventaja de ser capaces de representar directamente, de forma exacta, cualquier valor de precisión sencilla de punto flotante.

Las coordenadas de alta resolución de Java3D se utilizan sólo para incluir los sistemas de coordenadas tradicionales de punto flotante en un sistema de mucha mayor resolución. De esta forma se pueden crear universos de cualquier tamaño imaginable sin preocuparnos de la precisión.

Las coordenadas de alta resolución se representan como números de 256 bits con signo en complemento a dos. Aunque Java3D mantiene oculta la representación interna de las coordenadas de alta resolución, el usuario debe especificar dichas coordenadas usando matrices de enteros de 8 elementos. Java3D trata el entero en la posición 0 como los bits más significativos y el situado en la posición 7 como los menos significativos de la coordenada de alta resolución. El punto binario se localiza en el bit 128 o entre los enteros de las posiciones 3 y 4.

La forma en que los cargadores de ficheros manejan las coordenadas de alta resolución depende de cada cargador en concreto, ya que Java3D no define directamente ninguna semántica de carga de ficheros. Sin embargo, hay ciertas consideraciones que pueden indicarse.

Para universos pequeños (del orden de cientos de metros), un solo Locale con coordenadas de alta resolución ubicado en la posición (0.0, 0.0, 0.0) como el nodo raíz es suficiente. Un cargador puede construir automáticamente este nodo durante el proceso de carga ya que las coordenadas de alta resolución no necesitan tener una representación directa en el fichero externo.

Universos virtuales de mayor tamaño se suelen construir siguiendo la jerarquía habitual de directorios de cualquier disco duro, es decir, un universo virtual raíz que contiene la mayoría de las referencias a ficheros externos que incluyen universos virtuales. En este caso, el objeto que contiene la referencia al fichero define la localización de los datos que se tienen que leer en el universo virtual en cuestión.

El contenido de los ficheros de datos debe enlazarse al nodo mientras se leen, heredando así las coordenadas de alta resolución del objeto como el nuevo universo virtual origen del grafo de escena embebido. Si ese mismo grafo de escena contiene a su vez coordenadas de alta resolución, tendrán que ser trasladadas en la cantidad que indiquen esas coordenadas y entonces añadirlas al universo virtual mayor como nuevas coordenadas de alta resolución, con todo su contenido por debajo de las mismas.

A la hora de tratar con objetos que se mueven con gran amplitud, hay que considerar que tendrán que cambiar periódicamente su Locale padre de forma que se adapte más adecuadamente a sus nuevas coordenadas. Si no existiera ningún Locale suficientemente apropiado, la aplicación podría crear uno nuevo.

2.6 Modos De Renderización.

Java3D proporciona tres modos diferentes de renderización: modo inmediato, modo retenido y modo compilado–retenido. Están ordenados de forma creciente según el grado de libertad para optimizar la ejecución de la aplicación. Los dos últimos métodos son los más usados debido a las características de la gran mayoría de las aplicaciones.

Modo inmediato:

El modo inmediato no permite mucha optimización en cuanto al grafo de escena se refiere. En este modo, el nivel de abstracción de Java3D es bastante elevado y acelera el renderizado inmediato de los objetos. Una aplicación debe proporcionar un método de dibujado con un conjunto completo de puntos, líneas o triángulos que son posteriormente renderizados por el generador de imágenes de alta velocidad de Java3D. Por supuesto, la aplicación puede construir estas listas de puntos, líneas o triángulos en cualquier forma que elija. Este modo de renderización permite la mayor flexibilidad y libertad a costa de una reducción en el rendimiento.

En este modo Java3D no dispone de información acerca de los objetos gráficos de la composición. A causa de esto apenas se pueden realizar optimizaciones en la aplicación del programador. Este puede utilizar o no la estructura de grafo de escena heredada del diseño de Java3D; puede elegir entre dibujar la escena directamente o definir el grafo de escena. El modo inmediato puede utilizarse tanto de forma independiente como combinado con los otros dos métodos existentes.

Modo Retenido:

El modo retenido requiere que la aplicación construya un grafo de escena y que especifique qué elementos de dicho grafo de escena pueden cambiar durante la renderización. El grafo de escena describe los objetos del universo virtual, la distribución de dichos objetos y cómo la aplicación los anima. Este modo proporciona gran parte de la flexibilidad del modo inmediato a la vez que un incremento sustancial en la velocidad de renderización. Todos los objetos definidos en el grafo de escena son accesibles y manipulables, como lo es el grafo de escena en sí mismo. El programador puede crear grafos de escena y añadir o eliminar nodos del mismo rápidamente y ver inmediatamente los efectos de dichos cambios.

Este modo permite construir objetos, insertarlos en una base de datos, componer objetos y añadir comportamientos a los objetos. Java3D sabe que el programador ha definido objetos, sabe cómo ha combinado dichos objetos para crear objetos compuestos o grafos de escena y también conoce qué comportamientos o acciones se han añadido a los objetos.

Todo este conocimiento permite a Java3D realizar diferentes optimizaciones; puede construir estructuras de datos especiales que contengan la geometría de los objetos de tal forma que se aumente la velocidad a la que puede renderizarlo. Puede también compilar los comportamientos de los objetos para que se ejecuten a una mayor velocidad cuando sean invocados.

Modo compilado–retenido:

Este modo, al igual que el retenido, requiere que la aplicación construya un grafo de escena y que especifique qué elementos pueden cambiar durante la renderización. Además, la aplicación puede compilar parte o todos los subgrafos que forman el grafo de escena completo. Java3D compila estos grafos en un formato interno. La representación compilada del grafo de escena apenas se parece a la estructura de árbol original proporcionada por la aplicación, sin embargo, es funcionalmente equivalente. Este modo es el que proporciona el mejor rendimiento, permite que la API de Java3D realice una serie de complicadas optimizaciones. Un programador puede solicitar que Java3D compile un objeto o un grafo de escena. Un objeto o un grafo de escena compilado consiste en cualesquiera estructuras que Java3D quiera crear para asegurar que los objetos o grafos de escena se renderizan a la máxima velocidad posible. Como Java3D sabe que la mayor parte de los objetos o grafos de escena compilados no van a cambiar, puede realizar múltiples optimizaciones como pueden ser la fusión de múltiples objetos en un objeto conceptual, modificar un objeto para disponer de él en una geometría comprimida o incluso romper un objeto en diferentes partes y reensamblarlo en nuevos "objetos conceptuales".

2.7 Paquetes de Java3D.

Todos los programas de Java3D se forman, al menos parcialmente, uniendo distintos elementos de la jerarquía de clases de Java3D. Esa gran colección de objetos describe un universo virtual, que será posteriormente renderizado. La API define más de cien clases incluidas en el paquete javax.media.j3d. Estas clases son las normalmente denominadas como clases núcleo de Java3D.

Hay cientos de campos y métodos en dichas clases, sin embargo, un universo virtual sencillo que contenga algo de animación se puede construir con sólo unas pocas de ellas.

Además del paquete núcleo, a la hora de desarrollar programas en Java3D se utilizan otros paquetes. Uno de ellos es el paquete normalmente conocido como de utilidad (com.sun.j3d.utils).El paquete núcleo incluye sólo las clases de nivel más bajo necesarias para programar en Java3D.

Las clases de utilidad son extensiones muy prácticas y potentes. Como era de esperar, la utilización de clases de utilidad reduce significativamente el número de líneas de código a la hora de programar.

Por último, también se utilizan clases del paquete java.awt donde se define el Abstract Windowing Toolkit (AWT) que proporciona una ventana para visualizar la renderización y clases javax.vecmath que define clases matemáticas de vectores para puntos, vectores, matrices y otros objetos matemáticos.

3. El Primer Ejemplo: HelloJava3D.java

En este capítulo vamos a iniciar con un ejemplo bastante sencillo que nos ofrecerá un panorama general de las aplicaciones Java3D siguiendo el Algoritmo 2.1 (2.4. Construcción De Un Árbol), simplemente crearemos un cubo en un applet que estará embebido en un Frame. El código se mostrará por partes y al finalizar lo mostraremos completo.

3.1. HelloJava3D.java.

El ejemplo HelloJava3D.java es una clase definida para extender la clase Applet. La clase principal de un programa Java3D normalmente define un método para construir la rama de contenido gráfico. En el ejemplo HelloJava3D.java dicho método está definido como createSceneGraph(). Los pasos del algoritmo de la sección 2.4 se implementan en el constructor. El paso 1, crear un objeto Canvas3D, se observa en la línea 4 del listado 3.1. El paso 2, crear un objeto SimpleUniverse, se hace en la línea 11. El paso 2a, personalizar el objeto SimpleUniverse, se realiza en la línea 15. El paso 3, construir la rama de contenido, se encuentra en la llamada al método createSceneGraph(). El paso 4, compilar la rama de contenido gráfico, se hace en la línea 8. Finalmente el paso 5, insertar la rama de contenido gráfico en el objeto Locale del SimpleUniverse, se completa en la línea 16.

1. public class HelloJava3D extends Applet {

2. public HelloJava3D() {

3. setLayout(new BorderLayout());

4. Canvas3D canvas3D = new Canvas3D(null);

5. add("Center", canvas3D);

6.

7. BranchGroup scene = createSceneGraph();

8. scene.compile();

9.

10. // SimpleUniverse es una clase Convenience Utility

11. SimpleUniverse simpleU = new SimpleUniverse(canvas3D);

12.

13. // Mueve ViewPlatform atrás un bit, así el objeto de 14. //la escena podrá ser visto .

15. simpleU.getViewingPlatform().setNominalViewingTransform();

16.

17. simpleU.addBranchGraph(scene);

18. } // Fin de HelloJava3D (constructor)

Listado 3.1. Fragmento de HelloJava3D.java.

El paso 3 del algoritmo es crear la rama de contenido gráfico. Esta rama se crea en el Listado 3.2. Probablemente sea la rama de contenido gráfico más sencilla posible. Contiene un objeto gráfico estático, un ColorCube. Éste está localizado en el origen del sistema de coordenadas del universo virtual. Con la localización y orientación dadas de la dirección de la vista del cubo, el cubo aparece como un rectángulo cuando es renderizado (ver más adelante).

1. public BranchGroup createSceneGraph() {

2. // Crea la raíz del grafo branch

3. BranchGroup objRoot = new BranchGroup();

4. // Crea un nodo hoja de forma simple, añadiéndolo al grafo de escena

6. // ColorCube es una clase Convenience Utility

7. objRoot.addChild(new ColorCube(0.4));

8.

9. return objRoot;

10. } // Fin del método createSceneGraph de HelloJava3D

Listado 3.2. Método createSceneGraph de la clase HelloJava3D.

La clase HelloJava3D está derivada de Applet pero el programa puede ejecutarse como una aplicación con el uso de la clase MainFrame. Applet se usa como clase base para hacer más fácil la escritura de un programa Java3D que se ejecuta en una ventana.

MainFrame proporciona un marco AWT (ventana) para un applet permitiendo que se ejecute como una aplicación. El tamaño de la ventana resultante se especifica en la construcción de la clase MainFrame. El Listado 3.3 muestra el uso de MainFrame.

MainFrame crea un applet en una aplicación. Una clase derivada de Applet podría tener un método main() que llame al constructor MainFrame. Éste extiende java.awt.Frame e implementa java.lang.Runnable, java.applet.AppletStub, y java.applet.AppletContext.

MainFrame(java.applet.Applet applet, int width, int height) crea un objeto MainFrame que ejecuta un applet como una aplicación. Sus parámetros son los siguientes:

• applet: El constructor de una clase derivada de Applet. MainFrame proporciona un marco AWT para este applet.
• width: La anchura de la ventana en pixeles.
• height: La altura de la ventana en pixeles.

1. // Permite que el programa sea ejecutado tanto como una aplicación o como si

2. // fuera un applet

3.

4. public static void main(String[] args) {

5. Frame frame = new MainFrame(new HelloJava3D(), 256, 256);

6. } // Fin de main

7.

8.} // Fin de la clase HelloJava3D

Listado 3.3. Programa principal para HelloJava3D.

Los tres listados de código anteriores (3.1, 3.2, y 3.3) forman un programa Java3D completo cuando se usan las sentencias import adecuadas, en el Listado 3.4 podemos ver las necesarias para compilar la clase HelloJava3D. Las clases más comúnmente usadas en Java3D se encuentran en los paquetes javax.media.j3d, o javax.vecmath. En este ejemplo, sólo la clase de utilidad ColorCube se encuentra en el paquete com.sun.j3d.utils.geometry.

Consecuentemente, la mayoría de los programas Java3D tienen las sentencias import del Listado 3.4 con la excepción de ColorCube.

1. import java.applet.Applet;

2. import java.awt.BorderLayout;

3. import java.awt.Frame;

4. import java.awt.event.*;

5. import com.sun.j3d.utils.applet.MainFrame;

6. import com.sun.j3d.utils.universe.*;

7. import com.sun.j3d.utils.geometry.ColorCube;

8. import javax.media.j3d.*;

9. import javax.vecmath.*;

Listado 3.4. Sentencias Import para HelloJava3D.

En el programa de ejemplo HelloJava3D.java, sólo se situó un objeto gráfico en una única localización. En la Figura 3.1 podemos ver el escenario gráfico resultante.

Figura 3.1. Escenario gráfico de HelloJava3D.

Compilando y ejecutando el programa obtenemos la imagen de la Figura 3.2.

Figura 3.2. El programa HelloJava3D.java.

La siguiente sección presenta cada una de las clases usadas en el programa.

3.2 Clases Java3D Usadas en HelloJava3D.

Para añadir un poco de entendimiento del API Java3D y el ejemplo HelloJava3D aquí presentamos una sinopsis de las clases usadas en el programa de ejemplo.

Clase BranchGroup:

Los objetos de este tipo se usan para formar escenarios gráficos, son la raíz de los subgráficos, son los únicos que pueden ser hijos de los objetos Locale, pueden tener varios hijos, sus hijos pueden ser otros objetos Group o Leaf. El constructor por defecto es BranchGroup(), estos ejemplares de BranchGroup sirven como raíz para las ramas del escenario gráfico; y son los únicos que pueden insertarse en un conjunto de objetos Locale.

Clase Canvas3D:

La clase Canvas3D deriva de la clase Canvas del AWT. Al menos un objeto Canvas3D debe ser referenciado en la rama de vista gráfica del escenario gráfico. Su constructor es Canvas3D(GraphicsConfiguration graphicsconfiguration), éste construye e inicializa un nuevo objeto Canvas3D que el Java3D puede renderizar dando un objeto GraphicsConfiguration válido.

Clase Transform3D:

Los objetos Transform3D representan transformaciones de geometrías 3D como una traslación o una rotación. Normalmente sólo se usan en la creación de un objeto TransformGroup. Primero, se construye el objeto Transform3D, posiblemente desde una combinación de objetos Transform3D. Luego se construye el objeto TransformGroup usando el objeto Transform3D. Un objeto de transformación generalizado se representa internamente como una matriz de 4×4 de punto flotante. La representación matemática es la mejor forma. Un objeto Transform3D no se usa en un escenario gráfico. Se usa para especificar la transformación de un objeto TransformGroup.

El constructor por defecto es Transform3D() el cual construye un objeto Transform3D que representa la matriz de identidad (no la transformación). Cuando se especifica una rotación, el ángulo se expresa en radianes. Una rotación completa es 2p radianes. Una forma de especificar ángulos es usar la constante Math.PI. Otra forma es especificar los valores directamente. Algunas aproximaciones son: 45º es 0.785, 90º es 1.57, y 180º es 3.14.

Lista Parcial de Métodos de Transform3D:

Transform3D es una de las pocas clases que no se usan directamente en un escenario gráfico. Las transformaciones representadas por objetos de esta clase se usan para crear objetos TransformGroup que si se usan en escenarios gráficos. Algunos de sus métodos son los siguientes:

• void rotX(double angle): Selecciona el valor de esta transformación a una rotación en contra del sentido del reloj sobre el eje X. El ángulo se especifica en radianes.
• void rotY(double angle): Selecciona el valor de esta transformación a una rotación en contra del sentido del reloj sobre el eje Y. El ángulo se especifica en radianes.
• void rotZ(double angle): Selecciona el valor de esta transformación a una rotación en contra del sentido del reloj sobre el eje Z. El ángulo se especifica en radianes.

Clase TransformGroup:

Como una subclase de la clase Group, los ejemplares de TransformGroup se usan en la creación de escenarios gráficos y tienen una colección de objetos nodos como hijos. Los objetos TransformGroup contienen transformaciones geométricas como traslaciones y rotaciones. La transformación normalmente se crea en un objeto Transform3D, que no es un objeto del escenario gráfico. Sus constructores son los siguientes:

• TransformGroup(): Construye e inicializa un TransformGroup usando una identidad de transformación.
• TransformGroup(Transform3D t1): Construye e inicializa un TransformGroup desde un objeto Transform3D pasado como argumento.

La transformación contenida en un objeto Transform3D se copia a un objeto TransformGroup o cuando se crea el TransformGroup, o usando el método setTransform().

El Método void setTransform(Transform3D t1) de TransformGroup selecciona el componente de transformación de este TransformGroup al valor de la transformación t1 pasada como argumento.

Clase Vector3f:

Es una clase matemática que se encuentra en el paquete javax.vecmath para especificar un vector usando tres valores de punto flotante. Los objetos Vector se usan frecuentemente para especificar traslaciones de geometrías. Los objetos Vector3f no se usan directamente en la construcción de un escenario gráfico. Se usan para especificar las traslaciones, superficies normales, u otras cosas. Sus constructores son los siguientes:

• Vector3f(): Construye e inicializa un Vector3f a (0,0,0).
• Vector3f(float x, float y, float z): Construye e inicializa un Vector3f desde las coordenadas X, Y, Z especificadas.

Clase ColorCube:

ColorCube es una clase de utilidad que se encuentra en el paquete com.sun.j3d.utils.geometry que define la geometría y colores de un cubo centrado en el origen y con diferentes colores en cada cara. El objeto ColorCube es un cubo que tiene 2 metros de arista. Si un cubo sin rotar se sitúa en el origen (como en HelloJava3D), se verá la cara roja desde la localización de visión nominal. Los otros colores son azules, magenta, amarillos, verdes y cian. Sus constructores los mencionamos en seguida:

• ColorCube(): Construye un cubo de color y tamaño por defecto. En este caso, una esquina está situada a un metro de cada uno de los ejes desde el origen, resultando un cubo que está centrado en el sistema de coordenadas y tiene 2 metros de alto, de ancho y de profundo.
• ColorCube(double scale): Construye un cubo de color escalado por el valor especificado. El tamaño por defecto es 2 metros de lado. El ColorCube resultante tiene esquinas en (scale, scale, scale) y (-scale, -scale, -scale).

3.3. Listado Completo de HelloJava3D.

Para finalizar, simplemente listamos el código completo.

1. import java.applet.Applet;
2. import java.awt.BorderLayout;
3. import java.awt.Frame;
4. import java.awt.event.*;
5. import java.awt.GraphicsConfiguration;
6. import com.sun.j3d.utils.applet.MainFrame;
7. import com.sun.j3d.utils.universe.*;
8. import com.sun.j3d.utils.geometry.ColorCube;
9. import javax.media.j3d.*;
10. import javax.vecmath.*;
11. // HelloJava3D dibuja un único cubo que rota.
12. public class HelloJava3D extends Applet {
14. public HelloJava3D() {
16. setLayout(new BorderLayout());
18. GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration();
20. Canvas3D canvas3D = new Canvas3D(config);
21. add("Center", canvas3D);
23. BranchGroup scene = createSceneGraph();
25. // SimpleUniverse es una clase Convenience Utility
26. SimpleUniverse simpleU = new SimpleUniverse(canvas3D);
28. // Mueve ViewPlatform atrás un bit, así el objeto de la escena podrá ser visto
29. simpleU.getViewingPlatform().setNominalViewingTransform();
30. simpleU.addBranchGraph(scene);
32. } // Fin de HelloJava3D (constructor)
34. public BranchGroup createSceneGraph() {
36. // Crea la raíz del grafo branch
37. BranchGroup objRoot = new BranchGroup();
38. objRoot.addChild(new ColorCube(0.4));
39. return objRoot;
41. } // Fin del método CreateSceneGraph de HelloJava3D
43. // Permite que el programa sea ejecutado tanto como aplicación como un applet
45. public static void main(String[] args) {
47. Frame frame = new MainFrame(new HelloJava3D(), 256, 256);
49. } // Fin de main (método de HelloJava3D)
50. } // Fin de la clase HelloJava3D

Listado 3.5. Código completo de HelloJava3D.

4. Transformaciones.

En el capítulo anterior creamos un cubo, pero cuando lo ejecutamos parecía simplemente un cuadrado rojo, si necesitáramos algo así no tendría caso usar Java3D y bastaría con recurrir a Java2D. En el capítulo presente vamos a usar unos cuantos métodos de transformaciones que harán que ese cubo parezca un verdadero cubo, para ello, modificaremos el código que se presentó en el Listado 3.5.

4.1. Rotación Simple: HelloJava3Da.java.

La simple rotación de un cubo puede ser hecha para mostrar varias de sus caras. El primer paso es crear la transformación deseada usando un objeto del tipo Transform3D.

El listado 4.1 incorpora un objeto TransformGroup en el escenario gráfico para rotar el cubo sobre el eje X. La transformación de rotado es creada en la línea 6. La rotación se especifica usando el método rotX() en la línea 8. El objeto TransformGroup es creado en la línea 10 en base al objeto de rotado que queremos y que se creó en la línea 6.

Dos parámetros especifican la rotación: El eje de rotado y el ángulo de rotación. El eje es seleccionado usando el método apropiado (rotX, rotY, rotZ). El valor del ángulo es dado en el método empleado. Nosotros estamos rotando 45 grados.

El objeto objRotate genera el ColorCube como su hijo (línea 11). Finalmente, el objRoot hace a objRotate su hijo (línea 12).

1. public BranchGroup createSceneGraph() {

2. //Crea la raíz del grafo branch

3. BranchGroup objRoot = new BranchGroup();

5. // Objeto para rotar

6. Transform3D rotate = new Transform3D();

7.

8. rotate.rotX(Math.PI/4.0d);

9.

10. TransformGroup objRotate = new TransformGroup(rotate);

11. objRotate.addChild(new ColorCube(0.4));

12. objRoot.addChild(objRotate);

13. return objRoot;

14. } // Fin createSceneGraph

Listado 4.1. Rotación simple de un cubo.

El grafo resultante del Listado 4.1 puede verse en la Figura 4.1, en ella es más notoria la transformación, tenemos el nodo raíz de nuestro escenario BG, en ese nodo aplicamos el grupo de transformaciones TG, el cual tiene un nodo hijo, ColorCube, que, por tanto, tendrá los mismos cambios que su padre, en nuestro caso una simple rotación de 45º.

Sustituyendo el método createSceneGraph() del Listado 4.1 en HelloJava3D.java, y cambiando el nombre de la clase y del archivo a HelloJava3Da.java obtenemos el resultado de la Figura 4.2 después de compilar y ejecutar, en él ya notamos la cara superior del objeto.

4.2. Combinando Transformaciones: HelloJava3Db.java.

Ahora vamos a aplicar dos transformaciones sobre el cubo de HelloJava3Da, a este ejemplo le llamamos HelloJava3Db, nuevamente debemos modificar el método createSceneGraph(). Para este caso hay dos transformaciones diferentes las cuales pueden ser combinadas en una sola.

Dos rotaciones son combinadas en el Listado 4.2. Hacer estas dos operaciones simultáneas requiere mezclar dos objetos Transform3D de rotación. En el ejemplo se rota el cubo en torno a los ejes X y Y. Los objetos Transform3D, uno para cada rotación, son creados en las líneas 6 y 7. Las rotaciones individuales son especificadas por dos objetos TransformGroup (líneas 9 y 10). Entonces, las rotaciones son combinadas usando el método mul() en la línea 11. Por último, la combinación es colocada en el objeto TransformGroup (línea 12).

El resultado de estas transformaciones lo vemos en la Figura 4.3. Cabe decir que este es un ejemplo muy sencillo donde damos a conocer un poco de transformaciones, sin embargo, hay muchas otras que también se pueden combinar y que es imposible presentar aquí, éstas incluyen trasladado, escalado, etc.

1. public BranchGroup createSceneGraph() {

2. //Crea la raíz del grafo branch

3. BranchGroup objRoot = new BranchGroup();

4.

5. // Objetos para combinar

6. Transform3D rotate = new Transform3D();

7. Transform3D tempRotate = new Transform3D();

8.

9. rotate.rotX(Math.PI/4.0d);

10. tempRotate.rotY(Math.PI/5.0d);

11. rotate.mul(tempRotate);

12. TransformGroup objRotate = new TransformGroup(rotate);

13.

14. objRotate.addChild(new ColorCube(0.4));

15. objRoot.addChild(objRotate);

16. return objRoot;

17.}//Fin del método.

Listado 4.2. Combinando dos rotaciones.

Figura 4.3. Combinando transformaciones.

5. Animación: Behavior.

En Java3D, Behavior es una clase para especificar animaciones o interacción con objetos visuales. El comportamiento puede cambiar virtualmente cualquier atributo de un objeto. Un comportamiento es especificado por un objeto visual, Java3D actualiza la posición, orientación, color u otros atributos.

La diferencia entre animación e interacción es que la primera responde a ciertos eventos con el transcurso del tiempo, en cambio, la segunda responde a las actividades del usuario.

Cada objeto visual en el universo virtual puede tener su propio comportamiento definido. De hecho, pueden tener varios comportamientos. Para especificar un comportamiento de un objeto visual, el programador deberá crear los objetos que especifiquen el comportamiento, agregar el objeto visual al escenario gráfico y hacer las referencias apropiadas entre los objetos del escenario y los objetos de comportamientos.

Un interpolador es un número predefinido de clases y subclases Behavior en el paquete de Java3D. Basado en una función de tiempo, el objeto interpolador manipula los parámetros de los objetos en el escenario gráfico. Por ejemplo, la clase RotationInterpolator, manipula la rotación especificada por un TransformGroup para generar la rotación de los objetos visuales.

Al igual que hicimos en el capítulo 2, damos el Algoritmo 5.1 para guiarnos en la construcción de animaciones con Java3D, sus detalles se aclararán con un ejemplo más adelante:

1. Crear una instancia de TransformGroup.

a. Establecer la capacidad ALLOW_TRANSFORM_WRITE.

2. Crear un objeto Alpha.

a. Especificar los parámetros de tiempo para Alpha.

3. Crear el objeto interpolador.

a. Teniendo una referencia a los objetos Alpha y TransformGroup, optimizar los parámetros de comportamientos.

4. Especificar la región de planeación

a. Establecer la región de planeación para el comportamiento.

5. Hacer al comportamiento un hijo del TransformGroup.

Algoritmo 5.1. Construcción de animaciones en Java3D.

5.1. Especificando El Comportamiento.

Una acción de comportamiento puede ser un cambio en la posición (PositionInterpolator), orientación (RotationInterpolator), tamaño (ScaleInterpolator), color (ColorInterpolator), o transparencia (TransparencyInterpolator) de un objeto visual. Como se mencionó anteriormente, los interpoladores son clases de comportamientos predefinidas. Todo tipo de comportamientos pueden generarse sin interpoladores usando la animación clásica de Java, sin embargo, los interpoladores hacen estas tareas mucho más fáciles. Las clases de interpolación existen para proporcionar otras acciones, incluyendo combinaciones de ellas. La clase RotationInterpolator es usada más adelante como ejemplo.

Clase RotationInterpolator:

Esta clase es usada para especificar una rotación como comportamiento. Un objeto RotationIterpolator cambia un TransformGroup para especificar la rotación en respuesta al valor de un objeto Alpha. Dicho valor puede cambiar con el transcurso del tiempo. Un RotationInterpolator es flexible en su especificación la cual consiste en definir el eje de rotación y los ángulos inicial y final.

5.2. Variaciones de Tiempo Y Región de Planeación.

Para mapear una acción a cierto intervalo de tiempo debemos usar un objeto de la clase Alpha. La especificación de este objeto puede ser compleja, aquí presentamos la información básica para poder hacerlo.

Clase Alpha:

Los objetos de la clase Alpha son usados para crear una función de variación en el tiempo. Esta clase produce un valor entre cero y uno que depende del tiempo y los parámetros del objeto Alpha. Los objetos de esta clase son usados frecuentemente con interpoladores para completar animaciones.

En el paso cuatro del Algoritmo 5.1, se menciona que debemos especificar la región de planeación, esto se hace, en términos prácticos, para mejorar el rendimiento de nuestra animación y no haya demasiados problemas si contamos con una PC poco poderosa. Para conseguir esto nos valemos del método setSchedulingBounds de la clase Behavior.

Hay varias formas de definir una región de planeación, una de ellas es crear un objeto BoundingSphere.

Esta región de planeación nos sirve para que sólo cuando un objeto sea visible pueda mostrar el comportamiento que le fue asignado, no tendría caso gastar tiempo de CPU procesando objetos que el usuario no ve. De esta forma es como Java3D logra mejorar el rendimiento.

5.3. Ejemplo De Animación: HelloJava3Dc.

Nuevamente vamos a trabajar sobre el programa HelloJava3D en su método createSceneGraph(), le llamaremos HelloJava3Dc.java.

El Listado 5.1 muestra un ejemplo del uso de las clases de interpolación para crear una animación. Simplemente se realiza una rotación completa continua durante cuatro segundos. Obsérvese que éste código corresponde al Algoritmo 5.1 dado al inicio del capítulo.

El paso 1 del algoritmo es crear un objeto TransformGroup con la capacidad ALLOW_TRANSFORM_WRITE habilitada. El objeto TransformGroup es llamado objSpin y se crea en la línea 7. La capacidad de objSpin es establecida en la línea 8.

1. public BranchGroup createSceneGraph() {

2. // Crea la raíz del grafo

3. BranchGroup objRoot = new BranchGroup();

4.

5. // Crea e inicializa el grupo de transformación,

6. // lo agrega a el subgrafo

7. TransformGroup objSpin = new TransformGroup();

8. objSpin.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);

9. objRoot.addChild(objSpin);

10.

11. // Crea una hoja y la agrega al escenario

12. // ColorCube es una clase de utilidad Convenience

13. objSpin.addChild(new ColorCube(0.4));

14.

15. // Crea una funcion de variación en el tiempo

16. Alpha rotationAlpha = new Alpha(-1, 4000);

17.

18. // Crea un Nuevo comportamiento

19. // se especifican la operación y el grupo de transformación

20.

21. RotationInterpolator rotator =

22. new RotationInterpolator(rotationAlpha, objSpin);

23.

24. //Se especifica la región de planeación

25. BoundingSphere bounds = new BoundingSphere();

26. rotator.setSchedulingBounds(bounds);

27. objSpin.addChild(rotator);

28.

29. return objRoot;

30. } // fin del método createSceneGraph

Listado 5.1. Hellojava3Dc.

El paso 2 nos dice que debemos crear un objeto Alpha para manejar el interpolador, en el ejemplo, rotationAlpha es usado para especificar una rotación continua, los parámetros se dan en la línea 16, el primero es el número de iteraciones (- 1 para un ciclo continuo), el segundo para el tiempo de cada ciclo (4000 milisegundos = 4 segundos).

El paso 3 indica la creación del interpolador. El objeto RotationInterpolator para rotar se genera en las líneas 21 y 22. The interpolator must have references to the target transform and alpha objects. Los parámetros de su constructor deben ser el objeto Alpha y el grupo de transformación creados con anterioridad. En este ejemplo se usa el comportamiento predefinido de RotationInterpolator el cual genera una rotación completa alrededor del eje Y.

Especificar la región de planeación se lleva a cabo en el paso 4 del algoritmo, en nuestro código corresponde a las línea 25 y 26. Un objeto BoundingSphere es empleado para este propósito con su constructor por defecto.

El quinto y último paso hace al comportamiento hijo del grupo de transformación, en el Listado 5.1 esto se observa en la línea 27.

HelloJava3Dc crea el grafo de escena mostrado en la Figura 5.1. Por su parte, la Figura 5.2 muestra varias vistas de la animación hecha.

Figura 5.1. Grafo de HelloJava3Dc.

Figura 5.2. HelloJava3Dc ejecutándose.

5.4. Combinación de Transformaciones y Comportamientos: HelloJava3Dd.

Similar a lo que hicimos antes, podemos generar una combinación de transformaciones y comportamientos. En HelloJava3Dd.java veremos cómo. En los ejemplos anteriores utilizamos los objetos objRotate (HelloJava3Db, Listado 4.2) y objSpin (HelloJava3Dc, Listado 5.1), la diferencia entre ellos es que el primero se utiliza para realizar una rotación estática, mientras que el segundo para una rotación continua. El Listado 5.2 muestra el código modificado de createSceneGraph() para hacer una combinación de transformaciones y comportamientos usando los objetos mencionados.

El proceso a seguir es bastante fácil, primero hacemos lo mismo que en el Listado 4.2, combinar las transformaciones para ver varias caras del cubo (líneas 6 a 13), y posteriormente indicamos la rotación continua igual que en el Listado 5.1 (líneas 19 a 43).

Nótese que simplemente fue agregar al Listado 4.2 el código del Listado 5.1.

En la Figura 5.3 se muestra el grafo resultante, y en la Figura 5.4 una serie de imágenes que representan algunos movimientos del cubo (obsérvese la diferencia con la Figura 5.2).

1. public BranchGroup createSceneGraph() {

2. // Crea la raíz del grafo

3. BranchGroup objRoot = new BranchGroup();

4.

5. // Objetos a combinar

6. Transform3D rotate = new Transform3D();

7. Transform3D tempRotate = new Transform3D();

8.

9. rotate.rotX(Math.PI/4.0d);

10. tempRotate.rotY(Math.PI/5.0d);

11. rotate.mul(tempRotate);

12.

13. TransformGroup objRotate = new TransformGroup(rotate);

14.

15. // Crea e inicializa el grupo de transformación,

16.

17. // lo agrega a el subgrafo

18.

19. TransformGroup objSpin = new TransformGroup();

20. objSpin.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);

21.

22. objRoot.addChild(objRotate);

23. objRotate.addChild(objSpin);

24.

25. // Crea una hoja y la agrega al escenario

26. // ColorCube es una clase de utilidad Convenience

27. objSpin.addChild(new ColorCube(0.4));

28.

29. // Crea un Nuevo comportamiento

20.

31. // se especifican la operación y el grupo de transformación

32.

33. Alpha rotationAlpha = new Alpha(-1, 4000);

34.

35. RotationInterpolator rotator = new

36. RotationInterpolator(rotationAlpha, objSpin);

37.

38.

39. //Se especifica la región de planeación

40.

41. BoundingSphere bounds = new BoundingSphere();

42. rotator.setSchedulingBounds(bounds);

43. objSpin.addChild(rotator);

44.

45. return objRoot;

46. } // Fin de createSceneGraph

Listado 5.2. Código para combinar transformaciones.

Figura 5.3. Grafo para HelloJava3Dd.

Figura 5.4. HelloJava3Dd ejecutándose.

Bibliografía.

1. Advanced Animation and Rendering Techniques. Theory and Practices. Alan Watt and Mark Watt. New York, Addison Wesley Pub Company.
2. Interactive Control for Physically – Based Animation, in Computer Graphics Proceedings. Joseph Laszlo, Michiel van de Panne, Eugene Fiume. Annual Conference Series, 2000.
3. Inbetweening for Computer Animation Utilizing Moving Point Constaints. Reeves, W. T. SIGGRAPH 81, 263-269.
4. Adapting Simulated Behaviors For New Characters, en Computer Graphics. Jessica K. Hodgins and Nancy S. Pollard. (SIGGRAPH 97 roceedings), pp. 153-162, Addison Wesley, Agosto de 1997.
5. Computer Graphics Principles and Practice, Second Edition. J. D. Foley, A. van Dam, S.K. Feiner and J.F. Hughes. Addison Wesley Pub Company, 1990.
6. Bubblesort-Animation. Barbu, A., Dromowicz, M., Gao, X., Koester, M., and Wolf, C. 1998. Disponible en http://www-cg-hci.informatik.unioldenburg.de/˜da/fpsort/Animation.html.
7. G. Collection of ANIMAL Animations. R¨oßling, 1999. Disponible en .
8. Approaches for Generating Animations for Lectures. R¨oßling, G., and Freisleben, B. Proceedings of the 11th International Conference of the Society for Information Technology and Teacher Education (SITE 2000) (2000), 809–814.
9. Experiences In Using Animations in Introductory Computer Science Lectures. R¨oßling, G., and Freisleben, B. SIGCSE 2000 Proceedings (2000). To Appear.
10. Using Student-built Algorithm Animations as Learning Aids. Stasko, J. SIGCSE Session Proceedings (February 1997), 25–29.
11. Introducción a la Graficación por Computador. Foley, Dam, Feiner, Hughes, Philips. Addisson Wesley Iberoamericana, 1996.
12. Graficas por Computadora. Hearn/Baker. Printice Hall, 1995.
13. 3D Computer Graphics, Tercera edición. Alan Watt. Addison Wesley, 2000.
14. 3D Computer Animation. J. Vince. Addison Wesley, 1992.
15. The Animator's Workbook. Editorial Watson-Guptill Publication.
16. Animation cartoon. Preston Blair. Editorial Icara.
17. Digital Texturing & Lightning. Owen Demers. Editorial New Riders.
18. Generación electrónica de imágenes. Levitan, Eli L. Ediciones Bellatera S.A. Barcelona.
19. Wikipedia entry about Animation, www.wikipedia.org/wiki/Animation
20. The Aardman Book of 3D−Animation. ISBN 0500018812 o ISBN 0810919966.
21. Gimp Animation Tutorial. www.jimmac.musichall.cz/tutor.php3.
22. Gimp Tutorials. www.gimp.org/tutorials/
23. Brickfilms. www.brickfilms.com (dedicado a películas de detenimiento de movimiento con ladrillos y figuras Lego.
24. Gráficos con Java 2D. Juan Antonio Palos. http://java.programacion.com/ Versión Original en Ingles en http://java.sun.com
25. Java Swing Draw. Alfredo Casado Bernardez. http://creativecommons.org
26. Java Programming Language Guide. Bloch, J. Effective, 2001.
27. Documentación completa y descarga de Java y Java3D. http://java.sun.com/docs/
28. Thinking in Java. Bruce Eckel. http://www.planetpdf.com/, http://www.codecuts.com/, http://www.pdfforum.com/, http://www.pdfstore.com/. Prentice Hall, 2000.
29. Aprenda Java como si estuviera en primero. Javier García de Jalón. Campus Tecnológico de la Universidad de Navarra. 2000. www.tecnum.es
30. Java desde Cero. www.cybercursos.net
31. TutorJava Nivel Básico. Juan Antonio Palos. http://java.programacion.com/ Versión Original en Ingles en http://java.sun.com
32. Getting Started with the Java3D™ API. Dennis J Bouvier. www.sun.org
33. Visualization of object-oriented design models. Master’s thesis. Sunita Asija. Depaul University, Chicago, USA, December 1999.
34. Visualizing object-oriented software in virtual reality. Jonathan I. Maletic. 2001.
35. The Java3D API Specification. Henry Sowizral. Addison Wesley, second edition, 2000.

Luis Antonio Fernández Aldana

Parte del Proyecto de Servicio Social:

Evaluación de las Herramientas para el Desarrollo de Software Multimedia.

México.

Enero 2007.

Acerca del Autor: Luis Antonio Fernández Aldana egresó de la Facultad de Ciencias de la Computación de la Benemérita Universidad Autónoma de Puebla, México, en 2006, se ha dedicado en su formación a el área de multimedia, diseño y programación Web, le gusta compartir sus conocimientos lo cual se ve reflejado en los diversos trabajos que ha publicado gratuitamente en Internet.

Contacto: Sugerencias, comentarios y solicitud de la edición original de este y otros trabajos similares a y http://lamar.cs.buap.mx/~lafa

Nota: El software y otros elementos que aquí se describen o mencionan están protegidos por las correspondientes leyes de derechos de autor. Este manual es de libre distribución y se ha hecho como parte del proyecto de servicio social "Evaluación de las herramientas para la realización de software multimedia" de la Facultad de Ciencias de la Computación, Benemérita Universidad Autónoma de Puebla, México. Este trabajo se terminó de elaborar el 31 de Enero del 2007.