Java 3D

• Crear Contenidos Sencillos en Java 3D
• Cargadores
• Ejemplo de Usos de un Loader
• Cargadores Disponibles Públicamente
• Interfaces y Clases Base del Paquete Loader
• Escribir un Loader
• GeometryInfo
• Sencillo Ejemplo de GeometryInfo
• Clases para GeometryInfo
• Texto 2D
• Ejemplo de Text2D
• Clases Usadas para Crear Objetos Text2D
• Texto 3D
• Ejemplo de Text3D
• Clases Usadas en la Creación de Objetos Text3D
• Fondo
• Ejemplos de fondos
• La Clase BoundingLeaf
• Datos de Usuario

Crear Contenidos Sencillos en Java 3D

 Cargadores

Una clase Loader lee ficheros de escenas 3D (no ficheros Java 3D) y crea representaciones Java 3D de sus contenidos que pueden ser añadidos selectivamente a un mundo Java 3D y argumentados por otro código Java 3D. El paquete com.sun.j3d.loaders proporciona el contenido principal para convertir los ficheros creados en otras aplicaciones en aplicaciones Java 3D. Las clases cargadoras implementan el interface Loader definido en el paquete com.sun.j3d.loaders.

Como hay una gran variedad de formatos de ficheros para porpósitos de representación de escenas 3D (por ejemplo, .obj, .vrml, etc.) y siempre habrá más formatos de ficheros, el código real para cargar un fichero no forma parte de Java 3D o del paquete loaders; sólo se incluye el interface para el mecanismo de carga. Con la definición del interface, el usuario de Java 3D puede desarrollar clases cargadoras de ficheros con el mismo interface que las otras clases cargadoras.

 Ejemplo de Usos de un Loader

Sin una clase que realmente lea el fichero, no es posible cargar su contenido. Con una clase Loader es sencillo. La siguiente lista presenta la receta para usar un cargador.

1. encontrar un cargador (si no hay ninguno disponible, los escribimos)
2. importar la clase cargador para nuestro formato de fichero
3. importar otras clases necesarias
4. declarar una variable Scene (no usar el constructor)
5. crear un objeto loader
6. cargar el fichero en un bloque try, asignar el resultado a la variable Scene
7. insertar el Scene dentro del escenariog gráfico

Con el JDK 1.2 se distribuye una clase basada en este ejemplo, se encuentra en jdk1.2/demo/java3d/ObjLoad. El Fragmento de Código 3-1 presenta un extracto del código de esta demo.

La clase ObjectFile se distribuye con el paquete com.sun.j3d.loaders como ejemplo. La Tabla 3-1 muestra algunos otros ejemplos de cargadores disponibles.

1.     import com.sun.j3d.loaders.objectfile.ObjectFile;
2.     import com.sun.j3d.loaders.ParsingErrorException;
3.     import com.sun.j3d.loaders.IncorrectFormatException;
4.     import com.sun.j3d.loaders.Scene;
5.     import java.applet.Applet;
6.     import javax.media.j3d.*;
7.     import javax.vecmath.*;
8.     import java.io.*;
9.
10.   public class ObjLoad extends Applet {
11.
12.   private String filename = null;
13.
14.   public BranchGroup createSceneGraph() {
15.   // Create the root of the branch graph
16.   BranchGroup objRoot = new BranchGroup();
17.
18.   ObjectFile f = new ObjectFile();
19.   Scene s = null;
20.   try {
21.       s = f.load(filename);
22.   }
23.   catch (FileNotFoundException e) {
24.       System.err.println(e);
25.       System.exit(1);
26.   }
27.   catch (ParsingErrorException e) {
28.       System.err.println(e);
29.       System.exit(1);
30.   }
31.   catch (IncorrectFormatException e) {
32.       System.err.println(e);
33.       System.exit(1);
34.   }
35.
36.    objRoot.addChild(s.getSceneGroup());
37.   }

Este programa trata sobre añadir comportamientos (el efecto por defecto, o la interacción con el ratón - cubierto en el Capítulo 4) y luces (Capítulo 6) para proporcionar una renderización sombreada del modelo del objeto. Por supuesto, podemos hacer muchas otras cosas con el modelo en un programa Java 3D como añadir animaciones, añadir otras geométrias, cambiar el color del modelo, etc.

Dentro de la distribución del JDK 1.2 tenemos un ejemplo de loader en jdk1.2/demos/java3d/lightwave/Viewer.java. Este cargador carga las luces y animaciones espacificadas en un fichero .lws de Lightwave.

 Cargadores Disponibles Públicamente

En Java 3D existen varias clases cargadoras. La siguiente tabla lista los formatos de ficheros cuyos cargadores están disponibles públicamente. En el momento de escribir esto, al menos hay disponible una clase cargador por cada uno de estos formatos de fichero:

Tabla 3-1, Cargadores Java 3D disponibles Públicamente

Puedes localizar estos cargadores desde la página principal de Java 3D: http://java.sun.con/products/java-media/3d.

 Interfaces y Clases Base del Paquete Loader

Esta gran varidad de cargadores existe para hacer más sencilla la escritura de cargadores para los diseñadores Java 3D. Las clases Loader son implementaciones del interface Loader que baja el nivel de dificultad para escribir un cargador. Como en el ejemplo, un programa que carga un fichero 3D realmente usa un cargador y un objeto escena. El cargador lee, analiza y crea la representación Java 3D de los contenidos del fichero. El objeto escena almacena el escenario grafico creado por el cargador. Es posible cargar escenas desde más de un fichero (del mismo formato) usando el mismo objeto cargador y crear múltiples objetos escena. Los ficheros de diferentes formatos pueden combinarse en un programa Java 3D usando las clases cargadoras apropiadas.

El siguiente bloque de referencia lista los interface del paquete com.sun.j3d.loaders. Un loader implementa el interface loader y usa una clase que implementa el interface scene.

Además de estos interfaces, el paquete com.sun.j3d.loaders proporciona implementaciones básicas de los interfaces.

Scene load(java.io.Reader reader)

Scene load(java.lang.String fileName)

Scene load(java.net.URL url)

void setBasePath(java.lang.String pathName)

void setBaseUrl(java.net.URL url)

void setFlags(int flags)

La clase LoaderBase proporciona una implementación para cada uno de los tres métodos load() del interface Loader. LoaderBase también implementa dos constructores. Observa que los tres métodos cargadores devuelven un objeto Scene.

LoaderBase()

LoaderBase(int flags)

Background[] getBackgroundNodes()
Behavior[] getBehaviorNodes()
java.lang.String getDescription()
Fog[] getFogNodes()
float[] getHorizontalFOVs()
Light[] getLightNodes()
java.util.Hashtable getNamedObjects()
BranchGroup getSceneGroup()
Sound[] getSoundNodes()
TransformGroup[] getViewGroups()

 Escribir un Loader

Como se mencionó arriba, la característica más importante de los cargadores es que podemos escribir el nuestro propio, lo que significa que todos los usuarios de Java 3D también pueden hacerlo!

Para escribir un cargador, debemos extender la clase LoaderBase definida en el paquete com.sun.j3d.loaders. El nuevo cargador usará la clase Scene del mismo paquete.

Los futuros cargadores deberían tener poca necesitad de subclasificar SceneBase, o de implementar directamente Scene, ya que la funcionalidad de SceneBase es bastante correcta. Esta clase es responsable del almacenamiento y recuperación de datos creados por un cargador mientras lee un fichero. Los métodos de almacenamiento (usados sólo por los autores del Loader) son todas las rutinas add*. Los métodos recuperadores (usados principalmente por los usuarios de Loader) son todas las rutinas get*.

Escribir un cargador de ficheros puede ser bastante complejo dependiendo de la complejidad del formato del fichero. La parte más dura es analizar el fichero. Por supuesto, tenemos que empezar con la documentación del formato de fichero para el que queremos escribir la clase Loader. Una vez que se entiende el formato, empezamos leyendo las clase bases de loader y scene. La nueva clase loader extenderá la clase base loader y usará la clase base scene.

En la extensión del clase loader base, la mayoría del trabajo será escribir métodos que reconozcan los distintos tipos de contenidos que se pueden representar en el formato del fichero. Cada uno de esos métodos crea el correspondiente componente Java 3D del escenario gráfico y lo almacena en un objeto scene.

SceneBase()

 GeometryInfo

Si no tenemos acceso a los ficheros de modelos geométricos o a software de modelado geométrico, tenemos que crear nuestra geometría a mano. Como se mencionó en capítulos anteriores, esta codificación de geometría a mano requiere mucho tiempo y es una actividad muy propensa a errores. Como sabemos, cuando especifamos geometrías a través de las clases corazón, estamos limitados a triángulos y cuadrados. Usando las clase de utilidad GeometryInfo se puede mejorar el tiempo empleado y el trabajo tedioso de la creacción de geometrías. En lugar de especificar cada triángulo, podemos especificar polígonos arbitrarios, que pueden ser cóncavos, polígonos no planos, e incluso con agujeros. El objeto GeometryInfo, y otras clases de utilidad, convierten esta geometría en geometría tirangular que Java 3D puede renderizar.

Por ejemplo, si queremos crear un coche en Java 3D, en vez de especificar triángulos, podemos espcificar el perfil del coche como un polígono en un objeto GeometryInfo. Luego, usando un objeto Triangulator, el polígono puede subdividirse en triángulos. La imagen de la izquierda de la figura 3-2 muestra el perfil de un coche como un polígono. El imagen de la derecha es el polígonos subdividido en triángulos.

Si estamos interesados en el rendimiento, ¿y quién no?, usamos un objeto Stripifier para convertir los triángulos en franjas de triángulos. Si queremos sombrear el objeto visual, usamos el NormalGenerator para calcular las superficies y la geometría.

El programa GeomInfoApp.java, usa las clases GeometryInfo, Triangulator, Stripifier, y NormalGeneration para crear un coche. La Figura 3-3 muestra dos renderizaciones podrucidas por GeomInfoApp.java. En ambas, las líneas azules muestran los contornos especificados en el objeto GeometryInfo. Los triángulos rojos (rellenos y sombreados a la ziquierda y enmarcados a la derecha) fueron calculados automáticamente por el objeto GeometryInfo con Triangulation, NormalGeneration, y Stripification.

Un sencillo polígono plano, similar al de la figura 3-2, especifica el perfil de un coche (cada lado) en el ejemplo GeomInfoApp.

 Sencillo Ejemplo de GeometryInfo

Usar un objeto GeometryInfo es tan sencillo como usar las clases corazón GeomertryArray si no más sencillo. En la creacción de un objeto GeomertyInfo, simplemente especificamos el tipo de geometría que vamos a necesitar. Las opciones son POLYGON_ARRAY, QUAD_ARRAY, TRIANGLE_ARRAY, TRIANGLE_FAN_ARRAY, y TRIANGLE_STRIP_ARRAY. Entonces seleccionamos las coordenadas y el contador de franjas. No tenemos que decirle al objeto GeometryInfo cuántas coordenadas hay en los datos; se calcularán automáticamente.

El Fragmento de Código 3-2 muestra un ejemplo de aplicación GeometryInfo. Las líneas 1-3 muestran la creacción de un objeto GeometryInfo y la especificación de la geometría inicial.

Después de haber creado el objeto GeometryInfo, podrían usarse las otras clases. Si queremos usar el NormalGenerator, por ejemplo, primero creamos un objeto NormalGenerator, luego le pasamos el objeto GeometryInfo. Las líneas 8 y 9 hacen exactamente esto.

1.     GeometryInfo gi = new GeometryInfo(GeometryInfo.POLYGON_ARRAY);
2.     gi.setCoordinates(coordinateData);
3.     gi.setStripCounts(stripCounts);
4.
5.     Triangulator tr = new Triangulator();
6.     tr.triangulate(gi);
7.
8.     NormalGenerator ng = new NormalGenerator();
9.     ng.generateNormals(gi);
10.
11.   Stripifier st = new Stripifier();
12.   st.stripify(gi);
13.
14.   Shape3D part = new Shape3D();
15.   part.setAppearance(appearance);
16.   part.setGeometry(gi.getGeometryArray());

 Clases para GeometryInfo

La clase GeometryInfo y sus clases relacionadas son miembros del paquete com.sun.j3d.util.geometry y son subclases de Object. La Figura 3-4 muestra el árbol de estas clases.

La clase GeometryInfo sólo tiene un constructor y en él especificamos el tipo de geometría a especificar por las coordenadas.

GeometryInfo(int primitive)

La clase GeometryInfo tiene muchos métodos. Muchos de ellos son para seleccionar (u obtener) datos de coordenadas, colores, índices, superficies o de coordenadas de textura. La mayoría de las aplicaciones sólo usarán unos pocos de estos métodos. Sin embargo, es conveniente poder especificar la geometría a cualquier nivel de detalle y deja el resto calculado.

void recomputeIndices()

void reverse()

void setColorIndices(int[] colorIndices)

void setColors(Color3f[] colors)

void setColors(Color4f[] colors)

void setContourCounts(int[] contourCounts)

void setCoordinateIndices(int[] coordinateIndices)

void setCoordinates(Point3f[] coordinates)

void setCoordinates(Point3d[] coordinates)

void setNormalIndices(int[] normalIndices)

void setNormals(Vector3f[] normals)

void setNormals(float[] normals)

void setStripCounts(int[] stripCounts)

void setTextureCoordinateIndices(int[] texCoordIndices)

void setTextureCoordinates(Point2f[] texCoords)

Todas las clases de 'ayuda' de GeometryInfo se usan de forma similar. Los siguientes bloques de referencia muestran los constructoes y métodos para Triangulator, Stripifier, y NormalGenerator, en este orden, que es el orden en que se usarían para un POLYGON_ARRAY.

La utilidad Triangulator sólo se usa con geometría POLYGON_ARRAY. Otros objetos GeometryInfo con otras geometrías primitivas sólo usarían Stripifier y NormalGenerator.

El constructor por defecto para la clase Triangulator simplemente crea un objeto Triangulation.

Triangulator()

El único método de la clase Triangulator es para triangular un objeto GeometryInfo.

void triangulate(GeometryInfo gi)

El único constructor de la clase Stripifier crea un objeto stripification.

Stripifier()

El único método de la clase Stripifier es para convertir la geometría de un objeto GeometryInfo.

void stripify(GeometryInfo gi)

La clase NormalGenerator tiene dos constructores. El primero construye un NormalGenerator con un valor por defecto para el ángulo de pliegue. El segundo constructor permite la especificación del ángulo de pliegue.

NormalGenerator()

NormalGenerator(double radians)

Entre los métodos de la clase NormalGenerator se incluyen algunos para seleccionar u obtener el ángulo de pliegue, y cálculo de superficies para la geometría de un objeto GeometryInfo.

void generateNormals(GeometryInfo geom)

double getCreaseAngle()

void setCreaseAngle(double radians)

 Texto 2D

Hay dos formas de añadir texto a una escena Java 3D. Una forma es usar la clase Text2D y otra es usar la clase Text3D. Obviamente, la diferencia es que los objetos Text2D tienen dos dimensiones y los objetos Text3D tienen tres dimensiones. Otra diferencia significante es la forma en que se crean estos objetos.

Los objetos Text2D son polígonos rectangulares con el texto aplicado como una textura. Los objetos Text3D son objetos 3D geométricos creados como un extrusión del texto.

Como una subclase de Shape3D, los ejemplares de Text2D pueden ser hijos de objetos group. Para situar un objeto Text2D en una escena Java 3D, simplemente creamos el objeto Text2D y lo añadimos al escenario gráfico. Aquí tenemos una sencilla receta.

1. Crer un objeto Text2D
2. Añadirlo al escenario gráfico

Los objetos Text2D se implementan usando un polígono y una textura. El polígono es transparente para que sólo sea visible la textura. La textura es la cadena de texto seleccionada con los parámetros de fuente y tipo especifiados. Los tipos de letras disponibles dependen de nuestro sistema. Normalmente, están disponibles Courier, Helvetica, TimesRoman, entre otros. Cualquier fuente disponible en el AWT también está disponible para aplicaciones Text2D (y Text3D).

 Ejemplo de Text2D

El Fragmento de Código 3-3 muestra un ejemplo de adición de texto 2D a una escena. El objeto Text2D se crea en las líneas 21 a 23. En este constructor, se especifican la cadena de texto, el color, el tipo, el tamaño y el estilo de la fuente. El objeto Text2D se añade a la escena en la línea 24. Observa la sentencia import para Font (línea 5) usada para las constantes de estilos de fuente.

1.     import java.applet.Applet;
2.     import java.awt.BorderLayout;
3.     import java.awt.Frame;
4.     import java.awt.event.*;
5.     import java.awt.Font;
6.     import com.sun.j3d.utils.applet.MainFrame;
7.     import com.sun.j3d.utils.geometry.Text2D;
8.     import com.sun.j3d.utils.universe.*;
9.     import javax.media.j3d.*;
10.   import javax.vecmath.*;
11.
12.   // Text2DApp renders a single Text2D object.
13.
14.   public class Text2DApp extends Applet {
15.
16.   public BranchGroup createSceneGraph() {
17.   // Create the root of the branch graph
18.   BranchGroup objRoot = new BranchGroup();
19.
20.   // Create a Text2D leaf node, add it to the scene graph.
21.   Text2D text2D = new Text2D("2D text is a textured polygon",
22.   new Color3f(0.9f, 1.0f, 1.0f),
23.   "Helvetica", 18, Font.ITALIC));
24.   objRoot.addChild(text2D);

Text2DApp.java es un programa completo que incluye el fragmento de código anterior. En este ejemplo, el objeto Text2D rota sobre el origen de la escena. Cuando se ejecuta la aplicación podemos ver, por defecto, que el polígono texturado no es visible cuando se ve desde atrás.

Algunos atributos de un objeto Text2D se pueden modificar variando le paquete de apariencia referenciado y/o el NodeComponent. El Fragmento de Código 3-4 muestra el código que modifica el objeto text2d, creado en el Fragmento de Código 3-3.

25.   Appearance textAppear = text2d.getAppearance();
26.
27.   // The following 4 lines of code make the Text2D object 2-sided.
28.   PolygonAttributes polyAttrib = new PolygonAttributes();
29.   polyAttrib.setCullFace(PolygonAttributes.CULL_NONE);
30.   polyAttrib.setBackFaceNormalFlip(true);
31.   textAppear.setPolygonAttributes(polyAttrib);

La textura creada por un objeto Text2D también puede aplicarse a otros objetos visuales. Ya que la aplicación de texturas a objetos visuales es el objetivo del Capítulo 7 lo dejaremos aquí.

 Clases Usadas para Crear Objetos Text2D

La única clase necesaria es la clase Text2D. Como podemos ver de la Figura 3-7, Text2D es una clase de utilidad que desciende de Shape3D.

Text2D(java.lang.String text, Color3f color, java.lang.String fontName, 
		int fontSize, int fontStyle)

Con el constructor Text2D, hay un método. Este método selecciona el factor de escala para crear objetos Text2D mayores o menores que el tamaño de punto especificado. Este método no es útil en la versión 1.1.x del API, ya que sólo se utiliza cuando se especifica el texto. En la versión 1.2 se ha introducido un método setText() haciendo útil el setRectangleScaleFactor().

void setRectangleScaleFactor(float newScaleFactor)

 Texto 3D

Otra forma de añadir texto a un mundo virtual Java 3D es crear un objeto Text3D para texto. Mientras que Text2D crea el texto con un textura, Text3D crea texto usando geometría. La geometría textual de un objeto Text3D es una extrusión de la fuente.

Crear un objeto Text3D es un poco más complicado que crear un objeto Text2D. El primer paso es crear un objeto Font3D con el tipo de fuente, el tamaño y el estilo seleccionado. Luego se crea un objeto Text3D para una cadena particular usando el objeto Font3D. Como la clase Text3D es una subclase de Geometry, el objeto Text3D es un NodeComponent que es referenciado por uno o más objetos Shape3D:

1. Crear un objeto Font3D desde una fuente AWT
2. Crear un objeto Text3D para un string usando el objeto Font3D, opcionalmente especificando un punto de referencia
3. Referenciar el objeto desde un objeto Shape3D añadido al escenario gráfico

 Ejemplo de Text3D

El Fragmento de Código 3-5 muestra la construcción básica de un objeto Text3D. El objeto Font3D se crea en las líneas 19 y 20. El tipo usado es "Helvetica". Igual que en Text2D, cualquier tipo disponible en el AWT puede ser usado para Font3D y por lo tanto en el objeto Text3D. Este constructor de Font3D (líneas 19 y 20) también selecciona el tamaño de la fuente a 10 puntos y usa la extrusión por defecto.

La sentencia de las líneas 21 y 22 crea un objeto Text3D usando el objeto Font3D recientemente creado para la cadena "3DText" mientras especifica un punto de referencia para el objeto. Las últimas dos sentencias crean un objeto Shape3D para el objeto Text3D y lo añaden al escenario gráfico. Observa que la sentencia import de la línea 5 es necesaria porque se usa un objeto Font para la creacción de Font3D.

1.     import java.applet.Applet;
2.     import java.awt.BorderLayout;
3.     import java.awt.Frame;
4.     import java.awt.event.*;
5.     import java.awt.Font;
6.     import com.sun.j3d.utils.applet.MainFrame;
7.     import com.sun.j3d.utils.universe.*;
8.     import javax.media.j3d.*;
9.     import javax.vecmath.*;
10.
11.   // Text3DApp renders a single Text3D object.
12.
13.   public class Text3DApp extends Applet {
14.
15.   public BranchGroup createSceneGraph() {
16.   // Create the root of the branch graph
17.   BranchGroup objRoot = new BranchGroup();
18.
19.   Font3D font3d = new Font3D(new Font("Helvetica", Font.PLAIN, 10),
20.   new FontExtrusion());
21.   Text3D textGeom = new Text3D(font3d, new String("3DText"),
22.   new Point3f(-2.0f, 0.0f, 0.0f));
23.   Shape3D textShape = new Shape3D(textGeom);
24.   objRoot.addChild(textShape);

La Figura 3-9 muestra un objeto Text3D que ilustra la extrusión del tipo. En la figura, la extrusión se muestra en gris mientras que el tipo se muestra en negro. Para recrear esta figura en Java 3D, son necesarios un objeto Material y otro DirectionalLight. No podemos seleccionar el color de los vértices individuales en el objeto Text3D porque no tenemos acceso a la geometría del objeto Text3D.

El texto de un objeto Text3D puede orientarse de una gran cantidad de formas. La orientación se especifica como el camino de dirección. Las direcciones son right, left, up, y down.

Cada objeto Text3D tiene un punto de referencia. El punto de referencia para un objeto Text3D es el origen del objeto. El punto de referencia de cada objeto se define por la combinación del camino y la alineación del texto. La Tabla 3-2 muestra los efectos de las especificaciones del camino y la alineación sobre la orientación del texto y la situación del punto de referencia.

La situación del punto de referencia puede definirse explícitamente sobreescribiendo el camino y la alineación.

Los objetos Text3D tienen superficies. La adicción de un paquete de apariencia que incluye un objeto Material a un objeto Shape3D referenciando la geometría Text3D permitirá la iluminación del objeto Text3D.

 Clases Usadas en la Creación de Objetos Text3D

Esta sección presenta el material de referencia para tres clases usadas en la creacción de objetos Text3D: Text3D, Font3D, y FontExtrusion, en este orden. La Figura 3-10 muestra el árbol de clases de Text3D.

La clase Text3D define varios constructores. Cada uno permite especificar ninguno, uno o todos los atributos de un objeto Text3D.

Text3D()

Text3D(Font3D font3D)

Text3D(Font3D font3D, String string)

Text3D(Font3D font3D, String string, Point3f position)

Text3D(Font3D font3D, String string, Point3f position,
int alignment, int path)

La clase Text3D también define varios métodos. Cada uno de ellos nos permite modificar (seleccionar) los atributos del objeto Text3D. Esta clase también define los correspondientes métodos get*.

void setAlignment(int alignment)

void setCharacterSpacing(float characterSpacing)

void setFont3D(Font3D font3d)

void setPath(int path)

void setPosition(Point3f position)

void setString(java.lang.String string)

Cada objeto Text3D se crea desde un objeto Font3D. Un sólo objeto Font3D puede usarse para crear un número ilimitado de objetos Text3D. Un objeto Font3D contiene la extrusión geométrica de cada caracter en el tipo de letra. Un objeto Text3D copia las geometrías para formar la cadena especificada. Los objetos Font3D pueden ser recolectados por el recolector de basura sin afectar a los objetos Text3D creados a partir de él.

Font3D(java.awt.Font font, FontExtrusion extrudePath)

void getBoundingBox(int glyphCode, BoundingBox bounds)

java.awt.Font getFont()

void getFontExtrusion(FontExtrusion extrudePath)

La clase Font se usa en la creacción de un objeto Font3D.

public Font(String name, int style, int size)

FontExtrusion()

FontExtrusion(java.awt.Shape extrusionShape)

java.awt.Shape getExtrusionShape()

void setExtrusionShape(java.awt.Shape extrusionShape)

 Fondo

Por defecto, el fondo de un universo virtual Java 3D es negro sólido. Sin embargo, podemos especificar otros fondos para nuestros mundos virtuales. El API Java 3D proporciona una forma fácil de especificar un color sólido, una imagen, una geometría o una combinación de éstos como fondo.

Cuando especificamos una imagen para el fondo, se sobreescribie la especificación del color de fondo, si existe. Cuando se especifica una geometría, se dibuja sobre el color de fondo o la imagen.

La única parte espinosa es la especificación de un fondo geométrico. Toda la geometría de fondo se especifica como puntos en una esfera. Si nuestra geometría es un PointArray, que podría representar estrellas a años luz, o un TriangleArray, que podría representar montañas en la distancia. La geometria de fondo se proyecta sobre el infinito cuando se renderiza.

Los objetos Background tienen límites de aplicación, lo que nos permite que se puedan especificar diferentes fondos para diferentes regiones del mundo virtual. Un nodo Background está activo cuando su región de aplicación intersecciona con el volumen de activación del ViewPlatform.

Si están activos varios nodos Background,el nodo que está más "cercano" al ojo será el utilizado. Si no hay ningún nodo Background activo, la ventana se mostrará en negro. Sin embargo, la definición de "más cercano" no está especificada. Por cercano, se elige el fondo con los límites de aplicación más internos que encierra la ViewPlatform.

Es improbable que nuestra aplicación necesite iluminar la geometría del fondo -- en realidad el sistema visual humano no puede percibir los detalles visuales a grandes distancias. Sin embargo, una geometría de fondo si puede ser sombreada. La geometría del fondo podría no contener luces, pero las luces definidas en el escenario gráfico pueden influenciar en la geometría del fondo.

Para crear un fondo seguimos esta sencilla receta:

1. Crear un objeto Background especificando un color o una imagen.
2. Añadir geometría (opcional).
3. Proporcionar un límite de Aplicación o BoundingLeaf.
4. Añadir el objeto Background al escenario gráfico.

 Ejemplos de fondos

Como se explicó en la sección anterior, un fondo puede tener un color o una imagen. La Geometría puede aparecer en el fondo con el color o la imagen. Esta sección proporciona un ejemplo de un fondo blanco sólido. Un segundo ejemplo muestra la adicción de geométria al fondo.

Ejemplo de Fondo Coloreado

Las líneas de código del Fragmento de Código 3-6 corresponden con los pasos de la receta anterior. Junto a la personalización del color, el único posible ajuste es para definir unos límites de aplicación más apropiados para el fondo (o usar un BoundingLeaf).

1.     Background backg = new Background(1.0f, 1.0f, 1.0f);
2.     //
3.     backg.setApplicationBounds(BoundingSphere());
4.     contentRoot.addChild(backg);

Ejemplo de Geometría de Fondo

De nuevo, las líneas de código en el Fragmento de Código 3-7 corresponden con lo pasos de la receta de creacción de un fondo. En este fragmento, se llama al método createBackGraph() para crear la geometría del fondo. Este método devuelve un objeto BranchGroup. Para un ejemplo más completo puedes ver el fichero BackgroundApp.java.

1.     Background backg = new Background(); //black background
2.     backg.setGeometry(createBackGraph()); // add BranchGroup of background
3.     backg.setApplicationBounds(new BoundingSphere(new Point3d(), 100.0));
4.     objRoot.addChild(backg);

BackgroundApp.java

Para apreciar un fondo, necesitamos experimentarlo. BackgroundApp.java es una aplicación completa con un fondo geométrico. Esta aplicación nos permite movernos por un mundo virtual Java 3D. Mientras nos movemos, podemos ver el movimiento relativo entre la geometría local y la del fondo.

BackgroundApp.java usa la clase KeyNavigatorBehavior proprocionada por la librería de utilidades para visores de movimiento.

KeyNavigatorBehavior responde a las teclas de flechas, PgUp, y PgDn para el movimiento. La tecla Alt también juega un papel (para más detalles puedes ver el Capítulo 4. Cuando ejecutes BackgroundApp, no te olvides de rotar para ver la _constellation_, así como viajar lejos en la distancia.

La clase Background

La Figura 3-13 muestra el árbol de clase de la clase Background. Como una extensión de la clase Leaf, un ejemplar de la clase Background puede ser un hijo de un objeto Group.

Background tiene varios constructores. Los constructores con parámetros nos permiten especificar un color o una imagen para el fondo. La geometría del fondo sólo se puede aplicar a través del método apropiado.

Background()

Background(Color3f color)

Background(float r, float g, float b)

Background(ImageComponent2D image)

Cualquier atributo de un fondo puede seleccionarse a través de sus métodos.

void setApplicationBoundingLeaf(BoundingLeaf region)

void setApplicationBounds(Bounds region)

void setColor(Color3f color)

void setColor(float r, float g, float b)

void setGeometry(BranchGroup branch)

void setImage(ImageComponent2D image)

BoundingLeaf

Los Bounds (límites) se usan con luces, comportamientos, fondos y una gran variedad de otras aplicaciones en Java 3D. Los Bounds permiten al programador variar la acción, la apariencia, y/o el sonido sobre el campo virtual. La especificación de Bounds también permite al sistema de renderizado de Java 3D mejorar la ejecución del recortado y por lo tanto mejorar el rendimiento.

La especificación típica de límites utiliza un objeto Bounds para limitar una región. En el escenario gráfico resultante, los objetos Bounds se mueven con los objetos que lo referencian. Esto esta bién para muchas aplicaciones; sin embargo, podría haber situaciones en las que fuera deseable tener la región límite que se moviera independientemente de los objetos que usan los límites.

Por ejemplo, si un mundo incluye una fuente de luz estacionaria que ilumina unos objetos en movimiento, los límites de la luz deberían incluir el objeto en movimiento. Una forma de manejar esto podría ser crear los límites lo suficientemente grandes como para incluir todos los lugares donde se mueve el objeto. Esta no es la mejor respuesta en muchos casos. Una mejor solución es usar un BoundingLeaf. Situado en el escenario gráfico con el objeto visual, el BoundingLeaf se mueve con el objeto visual independientemente de la fuente de luz. La Figura 3-14 muestra un escenario gráfico con un una luz que usa un nodo BoundingLeaf.

Una aplicación interesante de un objeto BoundingLeaf sitúa un BoundingLeaf en la viewPlatform. Este BoundingLeaf puede usarse para un límite "siempre sobre" para un comportamiento, o para unos límites de aplicación "aplica siempre" para fondos o nieblas. El Fragmento de Código 3-8 presenta un ejemplo de la aplicación BoundingLeaf usada con un Background.

El Fragmento de Código 3-8 presenta un ejemplo de cómo añadir un BoundingLeaf como un hijo de PlatformGeometry para proporcionar un límite de "aplica siempre" para un fondo. En este código se ha modificado el método estándard createSceneGraph() para que tome un sólo parámetro, que es el objeto SimpleUniverse. Esto es necesario para crear el objeto PlatformGeometry.

Las líneas 2, 3 y 4 crean el objeto BoundingLeaf, el objeto PlatformGeometry y hace del objeto BoundingLeaf un hijo de PlatformGeometry, en este orden. Si tuviera que haber más objeto PlatformGeometry, se añadirían en este punto. El objeto PlatformGeometry se añade la rama de vista gráfica en la línea 6.

El objeto BoundingLeaf se selecciona como los limites de aplicación para el objeto background en la línea 11. El mismo objeto BoundingLeaf puede usarse para otros propósitos en este programa. Por ejemplo, puede usarse para los comportamientos. Observa que usando el BoundingLeaf en este programa como el InfluencingBoundingLeaf de una luz hace que esta luz no influya en todos los objetos del mundo virtual.

1.     void createSceneGraph (SimpleUniverse su) {
2.     BoundingLeaf boundingLeaf = new BoundingLeaf();
3.     PlatformGeometry platformGeom = new PlatformGeometry();
4.     platformGeom.addChild(boundingLeaf);
5.     platformGeom.compile();
6.     simpleUniv.getViewingPlatform().setPlatformGeometry(platformGeom);
7.
8.     BranchGroup contentRoot = new BranchGroup();
9.
10.   Background backg = new Background(1.0f, 1.0f, 1.0f);
11.   backg.setApplicationBoundingLeaf(boundingLeaf);
12.   contentRoot.addChild(backg);

 La Clase BoundingLeaf

La clase BoundingLeaf extiende la clase Leaf. La Figura 3-15 representa el árbol de clases de BoundingLeaf.

El constructor sin parámetros de BoundingLeaf crea límites para una esfera. El otro constructor permite la especificación de límites para el objeto BoundingLeaf.

BoundingLeaf()

BoundingLeaf(Bounds region)

Bounds getRegion()

void setRegion(Bounds region)

 Datos de Usuario

Cualquier SceneGraphObject puede referenciar cualquier otro objeto como datos de usuario. Primero, deberíamos habernos dado cuenta de que casi cualquier clase del corazón del API Java 3D es un descendiente de SceneGraphObject. La lista de descendientes de SceneGraphObject incluye Appearance, Background, Behavior, BranchGroup, Geometry, Lights, Shape3D, y TransformGroup.

Las aplicación para el campo UserData, sólo está limitado por nuestra imaginación. Por ejemplo, una aplicación podría tener varios objetos recolectables. Cada uno de estos objetos podría tener algún texto informativo almacenado en el objeto de datos de usuario. Cuando el usuario recoge un objeto, se puede mostrar la información de los datos de usuario.

Otra aplicación podría almacenar algún valor calculado para un objeto de escenario gráfico como su posición en las coordenadas del mundo virtual. Y otra aplicación podría almacenar alguna información especifica de comportamiento que podría controlar el comportamiento aplicado a varios objetos.

java.lang.Object getUserData()

void setUserData(java.lang.Object userData)