Java 3D

Hay tres formas principales de crear contenidos geom�tricos. Una forma es usar las clases de utilidades geom�tricas para box, cone, cylinder, y sphere. Otra forma es especificar coordenadas de v�rtices para puntos, segmentos de l�neas y/o superficies poligonales. Una tercera forma es usar un cargador geom�trico. Esta p�gina demuestra la creacci�n de contenidos geom�tricos de las dos primeras formas.

.�Sistema de Coordenadas del Mundo Virtual

Como se explic� en la p�gina anterior, un ejemplar de la clase VirtualUniverse sirve como ra�z para el escenario gr�fico de todos los programas Java 3D. El t�rmino 'Universo Virtual' comunmente se refiere al espacio virtual de tres dimensiones que rellenan los objetos Java 3D. Cada objeto Locale del universo virtual establece un sistema de coordenadas Cartesianas.

Un objeto Locale sirve como punto de referencia para los objetos visuales en un universo virtual. Con un Locale en un SimpleUniverse, hay un sistema de coordenadas en el universo visrtual.

El sistema de coordenadas del universo virtual Java 3D es de mano derecha. El eje X es positivo hacia la derecha, el eje Y es positivo hacia arriba y el eje Z es positivo hacia el espectador, con todas las unidades en metros. La Figura 2-1 muestra la orientaci�n con respecto al espectador en un SimpleUniverse.

Figura 2-1. Orientaci�n de Ejes en un Mundo Virtual

.�Definici�n B�sica de Objeto Visual

.�Un Ejemplar de Shape3D Define un Objeto Visual

Un nodo Shape3D de escenario gr�fico define un objeto visual. Shape3D es una de las subclases de la clase Leaf; por lo tanto, los objetos Shape3D s�lo pueden ser hojas en un escenario gr�fico. El objeto Shape3D no contiene informaci�n sobre la forma o el color de un objeto visual. Esta informaci�n est� almacenada en los objetos NodeComponent referidos por el objeto Shape3D. Un objeto Shape3D puede referirse a un componente nodo Geometry y a un componente nodo Appearance.

En los escenarios gr�ficos de la p�gina anterior, el s�mbolo de objeto gen�rico (rect�ngulo) fue utilizado para representar el objeto ColorCube. El sencillo escenario gr�fico de la Figura 2-2 muestra un objeto visual representado como un hoja Shape3D (tri�ngulo) y dos NodeComponents (�valos) en lugar del rect�ngulo gen�rico.

Figura 2-2. Un Objeto Shape3D Define un Objeto Visual en un Escenario Gr�fico

Un objeto visual se puede definir usando s�lo un objeto Shape3D y un nodo componente Geometry. Opcionalmente, el objeto Shape3D tambi�n se refiere a un nodo componente Appearance. Los constructores de Shape3D muestran que se pueden crear sin referencias a componentes nodos, con s�lo una referencia a un nodo Geometry, o con referencias a �mbos tipos de componentes.

Constructores de Shape3D

Shape3D()

Construye e inicializa un objeto Shape3D sin ning�n tipo de componentes.

Shape3D(Geometry geometry)

Construye e inicializa un objeto Shape3D con la geometr�a especificada y un componente de apariencia nulo.

Shape3D(Geometry geometry, Appearance appearance)

Construye e inicializa un objeto Shape3D con los componentes de geometr�a y apariencia especificados.

Mientras que el objeto Shape3D no est� vivo o compilado, las referencias a los componentes pueden modicarse con los m�todos del siguiente recuadro. Estos m�todos pueden usarse sobre objetos Shape3D vivos o compilados si se configuran las capacidades del objeto primero. El otro recuadro lista las capacidades de Shape3D.

Lista Parcial de M�todos de Shape3D

Un objeto Shape3D referencia a objetos NodeComponente: Geometry y/o Appearance. Junto con los m�todos de configuraci�n mostrados aqu�, tambi�n existen los complementarios m�todos get

void setGeometry(Geometry geometry)
void setAppearance(Appearance appearance)

Capacidades de Shape3D

Los objetos Shape3D tambi�n heredan capacidades de las clases SceneGrpahObject, Node, y Leaf.

ALLOW_GEOMETRY_READ | WRITE
ALLOW_APPEARANCE_READ | WRITE
ALLOW_COLLISION_BOUNDS_READ | WRITE

.�NodeComponent

Los objetos NodeComponent contienen las especificaciones exactas de los atributos de un objeto visual. Cada una de las muchas subclases de NodeComponent define ciertos atributos visuales. La Figura 2-3 muestra una parte del �rbol del API Java 3D que contiene las clases NodeComponent y sus descendientes.

Figura 2-3. Visi�n Parcial del �rbol de Clases de Java 3D Mostrando las Subclases de NodeComponent

.�Definir Clases de Objetos Visuales

El mismo objeto visual puede aparecer muchas veces en un s�lo universo virtual. Tiene sentido definir una clase para crear el objeto visual en lugar de construir cada objeto visual desde el principio. Hay varias formas de dise�ar una clase que define un objeto visual.

El fragmento de c�digo 2-1 muestra el c�digo esqueleto de la clase VisualObject como ejemplo de una organizaci�n posible para una clase de un objeto visual. Los m�todos no tienen c�digo. El c�digo de VisualObject no aparece en los ejemplos porque no es particularmente �til.

1. public class VisualObject extends Shape3D{
2.
3.     private Geometry voGeometry;
4.     private Appearance voAppearance;
5.
6.     // create Shape3D with geometry and appearance
7.     // the geometry is created in method createGeometry
8.     // the appearance is created in method createAppearance
9.     public VisualObject() {
10.
11.   voGeometry = createGeometry();
12.   voAppearance = createAppearance();
13.   this.setGeometry(voGeometry);
14.   this.setAppearance(voAppearance);
15.   }
16.
17.   private Geometry createGeometry() {
18.   // code to create default geometry of visual object
19.   }
20.
21.   private Appearance createAppearance () {
22.   // code to create default appearance of visual object
23.   }
24.
25. } // end of class VisualObject

La organizaci�n de la clase VisualObject en el Fragmento de C�digo 2-1 es similar a la clase ColorCube que extiende un objeto Shape3D. Sugerimos la clase VisualObject como punto de arranque para definir clases con contenidos personalizados para usarlos en construcci�n de escenarios gr�ficos. Para ver un ejemplo completo de la organizaci�n de esta clase puedes leer el c�digo fuente de la clase ColorCube que est� en el paquete com.sun.j3d.utils.geometry, que est� disponible en la distribuci�n del API Java 3D.

Usar Shape3D como base para la creaci�n de clases de objetos visuales facilita su uso en programas Java 3D. Las clases de objetos visuales pueden usarse tan facilmente como la clase ColorCube en los ejemplos HelloJava3D de la p�gina anterior. Se puede llamar al constructor e insertar el objeto creado como hijo de alg�n Group en una l�nea del codigo. En la siguiente l�nea de ejemplo, objRoot es un ejemplar de Group. Este c�digo crea un VisualObject y lo a�ade como hijo de objRoot en el escenario gr�fico:

objRoot.addChild(new VisualObject());

El constructor VisualObject crea el VisualObject creando un objeto Shape3D que referencia al NodeComponents creado por los m�todos createGeometry() y createAppearance(). El m�todo createGeometry() crea un NodeComponent Geometry para suarlo en el objeto visual. El m�todo createAppearance() es responsable de crear el NodeComponent que define la Appearance del objeto visual.

Otra posible organizaci�n de un objeto visual es definir una clase contenedor no derivada del API de clases Java 3D. En este dise�o, la clase del objeto visual podr�a contener un Group Node o un Shape3D como la ra�z del sub-gr�fico que define. La clase debe definir m�todo(s) para devolver una referencia a su ra�z. Esta t�cnica tiene un poco m�s de trabajo, pero podr�a ser m�s f�cil de entender.

Una tercera organizaci�n posible de una clase de objeto visual es una similar a las clases Box, Cone, Cylinder, y Sphere definidas en el paquete com.sun.j3d.utils.geometry. Cada clase desciende de Primitive, que a su vez desciende de Group. Los detalles de dise�o de Primitive y sus descendientes no se explican en este turorial, pero el c�digo fuente de todas estas clases est� disponible con la distribuci�n del API Java 3D. Del c�digo fuente de la clase Primitive y de otras clases de utilidad, el lector puede aprender m�s sobre esta aproximaci�n al dise�o de clases.

.�Clases de Utilidades Geom�tricas

Esta secci�n cubre las clases de utilidad para crear gr�ficos primitivos geom�tricos como cajas, conos, cilindros y esferas. Los primitivos geom�tricos son la segunda forma m�s f�cil para crear contenidos en un universo virtual. La m�s f�cil es usar la clase ColorCube.

Las clases primitivas proporcionan al programador m�s flexibilidad que la clase ColorCube. Un objeto ColorCube define la geometr�a y el c�lor en un componente Geometry. Consecuentemente, todo en el ColorCube es fijo, excepto su tama�o. El tama�o de un ColorCube s�lo se especifica cuando se crea.

Un objeto primitivo proporciona m�s flexibilidad especificando la forma sin especificar el color. En una clase de utilidad geom�trica primitiva, el programador no puede cambiar la geometr�a, pero puede cambiar la apariencia. Las clases primitivas le dan al programador la flexibilidad de tener varios ejemplares de la misma forma geom�trica primitiva donde cada una tiene una apariencia diferente haciendo una referencia a un NodeComponent de apariencia diferente.

Las clases de utilidad Box, Cone, Cylinder y Sphere est�n definidas en el paquete com.sun.j3d.utils.geometry. En la Figura 2-3 podemos ver la porci�n del paquete com.sun.j3d.utils.geometry que contiene las clases primitivas.

Figura 2-4. �rbol de Clases de las Clases Geom�tricas Primitivas

.�Box

La clase geom�trica Box crea cubos de 3 dimensiones. Los valores por defecto para la longitud, anchura y altura son 2 metros, con el centro en el origen, resultando en un cubo con esquinas en ( -1, -1, -1) y ( 1, 1, 1). La longitud, la anchura y la altura pueden especificarse en el momento de la creacci�n del objeto. Por supuesto, se pueden usar TransformGroup junto con el camino del escenario gr�fico a un Bos para cambiar la localizaci�n u orientaci�n de los ejemplares creados con Box.

Box

Paquete: com.sun.j3d.utils.geometry

Box desciende de Primitive, otra clase del paquete com.sun.j3d.utils.geometry.

Box()

Construye un cubo por defecto con 2,0 metros de altura, anchura y profundidad, centrado en el origen.

Box(float xdim, float ydim, float zdim, Appearance appearance)

Construye un cubo con las dimensiones y apariencia dadas, centrado en el origen.

Mientras que los constructores son diferentes para cada clase, las clases Box, Cone, y Cylinder comparten los mismos m�todos:

M�todos de Box, Cone, y Cylinder

Paquete: com.sun.j3d.utils.geometry

Estos m�todos est�n definidos en todas las clases primitivas: Box, Cone, y Cylinder. Estos Primitivos se componen de varios objetos Shape3D en un grupo.

Shape3D getShape(int id)

Obtiene una de las caras (Shape3D) del primitivo que contiene la geometr�a y apariencia. Los objetos Box, Cone, y Cylinder est�n compuestos por m�s de un objeto Shape3D, cada uno con su propio componente Geometry.

void setAppearance(Appearance appearance)

Selecciona la apariencia del primitivo (para todos los objetos Shape3D).

.�Cone

La clase Cone define conos centrados en el origen y con el eje central alineado con el eje Y. Los valores por defecto para el radio y la altura son 1,0 y 2,0 metros respectivamente.

Lista Parcial de Constructores de Cone

Paquete: com.sun.j3d.utils.geometry

Cone desciende de Primitive, otra clase del paquete com.sun.j3d.utils.geometry.

Cone()

Construye un cono con los valores de radio y altura por defecto.

Cone(float radius, float height)

Construye un cono con el radio y altura especificados.

.�Cylinder

La clase Cylinder crea objetos cil�ndricos con sus eje central alineado con el eje Y. Los valores por defecto para el radio y la altura son 1,0 y 2,0 metros respectivamente.

Lista Parcial de Constructores de Cylinder

Paquete: com.sun.j3d.utils.geometry

Cylinder desciende de Primitive, otra clase del paquete com.sun.j3d.utils.geometry.

Cylinder()

Construye un cilindro con los valores de radio y altura por defecto.

Cylinder(float radius, float height)

Construye un cilindro con los valores de radio y altura especificados.

Cylinder(float radius, float height, Appearance appearance)

Construye un cilindro con los valores de radio, altura y apariencia especificados.

.�Sphere

La clase Sphere crea objetos visuales esf�ricos con el centro en el origen. El radio por defecto es de 1,0 metros.

Lista Parcial de Constructores de Sphere

Paquete: com.sun.j3d.utils.geometry

Sphere desciende de Primitive, otra clase del paquete com.sun.j3d.utils.geometry.

Sphere()

Construye una esfera con el radio por defecto (1,0 metros)

Sphere(float radius)

Construye una esfera con el radio especificado.

Sphere(float radius, Appearance appearance)

Construye una esfera con el radio y la apariencia especificados.

M�todos de Sphere

Paquete: com.sun.j3d.utils.geometry

Como una extensi�n de Primitive, un Sphere es un objeto Group que tiene un s�lo objeto hijo Shape3D.

Shape3D getShape()

Obtiene el Shape3D que contiene la geometr�a y la apariencia.

Shape3D getShape(int id)

Este m�todo se incluye por compatibilidad con otras clases primitivas: Box, Cone, y Cylinder. Sin embargo, como una Sphere s�lo tiene un objeto Shape3D, s�lo puede ser llamado con id = 1.

void setAppearance(Appearance appearance)

Selecciona la apariencia de la esfera.

.�M�s Sobre los Geom�tricos Primitivos

La geometr�a de una clase de utilidad primitiva no define el color. La Geometry que no define el color deriva su color desde su componente Appearance. Sin una referencia a un nodo Appearance, el objeto visual ser�a blanco, el color por defecto.

La clase Primitive define valores por defecto comunes para Box, Cone, Cylinder, y Sphere. Por ejemplo, define el valor por defecto para el n�mero de pol�gonos usado para representar superficies.

.�ColorCube

La clase ColorCube se presenta aqu� para constrastarla con las clases primtivas. Esta clase desciende de otra parte del �rbol de clases Java 3D. Este �rbol de clases podemos verlo en la Figura 2-5.

Figura 2-5. �rbol de Clases de la Clases de utilidad ColorCube

ColorCube es la �nica clase distribuida con el API Java 3D que permite a los programadores ignorar los problemas con los colores y las luces. Por esta raz�n, la clase ColorCube es �til para ensamblar r�pidamente escenario gr�ficos para probar prototipos.

.�Ejemplo: Crear un Simple Yo-Yo desde dos Conos

Esta secci�n presenta un sencillo ejemplo que usa la clase Cone: ConeYoyoApp.java. El objetivo del programa es renderizar un yo-yo. Se usan dos conos para formar el yo-yo. Se puede usar el API de comportamientos de Java 3D para hacer que el yo-yo se mueva de arriba a arriba, pero esto va m�s all� del �mbito de esta p�gina. El programa gira el yo-yo para que se puedan apreciar las geometr�as. El diagrama del escenario gr�fico de la Figura 2-6 muestra el dise�o de las clases ConeYoyo y ConeYoyoApp del programa de ejemplo.

La posici�n por defecto del objeto Cone es con su caja de limites centrada en el origen. La orientaci�n por defecto es con la punta del objeto Cone en direcci�n a los positivos del eje Y. El yo-yo est� formado por dos conos que se rotan sobre el eje Z y se trasladan a lo largo del eje X para poner juntas las puntas de los dos conos en el origen. Se pordr�an utilizar otras combinaciones de rotaciones o traslaciones para conseguir que se juntaran las puntas de los conos.

Figura 2-6. Escenario Gr�fico de la Aplicaci�n ConeYoyo

En la rama gr�fica que empieza con el objeto BranchGroup creada por el objeto ConeYoyo, el camino de escenario gr�fico a cada objeto Cone empieza con el objeto TransformGroup que especifica la traslaci�n, seguido por el TransformGroup que especifica la rotaci�n, y termina en el objeto Cone.

Varios escenarios gr�ficos podr�an presentar el mismo mundo virtual. Tomando el escenario gr�fico de la Figura 2-6 como ejemplo, se pueden hacer algunos cambios obvios. Un cambio elimina el objeto BranchGroup cuyo hijo es el objeto ConeYoyo e inserta el objeto ConeYoyo directamente en el objeto Locale. Otro cambio combina los dos objetos TransformGroup dentro del objeto ConeYoyo. Las transformaciones se han mostrado s�lo como ejemplos.

Los nodos Shape3D de los objetos Cone referencian a los componentes Geometry. Estos son internos al objeto Cone. Los objetos Shape3D del Cone son hijos de un Group en el Cone. Como los objetos Cone descienden de Group, el mismo Cone (u otro objeto Primitivo) no puede usarse m�s de una vez en un escenario gr�fico. Abajo podemos ver un ejemplo de mensaje de error producido cuando intentamos usar el mismo objeto Cone dos veces en un �nico escenario gr�fico. Este error no existe en el programa de ejemplo distribuido en este tutorial.

Exception in thread "main" javax.media.j3d.MultipleParentException:
Group.addChild: child already has a parent
     at javax.media.j3d.GroupRetained.addChild(GroupRetained.java:246)
     at javax.media.j3d.Group.addChild(Group.java:241)
     at ConeYoyoApp$ConeYoyo.<init>(ConeYoyoApp.java:89)
     at ConeYoyoApp.createSceneGraph(ConeYoyoApp.java:119)
    at ConeYoyoApp.<init>(ConeYoyoApp.java:159)
    at ConeYoyoApp.main(ConeYoyoApp.java:172)
Figura 2-8. Una Imagen Renderizada de ConeYoyoApp.java

La Figura 2-8 muestra una de las posibles imagenes renderizadas por ConeYoyoApp.java como el objeto ConeYoyo. En el Fragmento de C�digo 2-2 podemos ver el c�digo del programa.

Las l�neas de 14 a 21 crean los objetos de una mitad del escenario gr�fico del yo-yo. La l�neas 23 a 25 crean la relaciones entre estos objetos. El proceso se repite para la otra mitad del yo-yo en las l�neas 27 a 38.

La l�nea 12 crea yoyoAppear, un componente nodo Appearance con valores por defecto, para usarlo en los objeto Cone. La l�neas 21 a 34 seleccionan los par�metros de los dos conos.

Fragmento de C�digo 2-2. La clase ConeYoyo del programa ConeYoyoApp.java
1. public class ConeYoyo{
2.
3.     private BranchGroup yoyoBG;
4.
5.     // create Shape3D with geometry and appearance
6.     //
7.     public ConeYoyo() {
8.
9.     yoyoBG = new BranchGroup(); 
10.   Transform3D rotate = new Transform3D();
11.   Transform3D translate = new Transform3D();
12.   Appearance yoyoAppear = new Appearance();
13.
14.   rotate.rotZ(Math.PI/2.0d);
15.   TransformGroup yoyoTGR1 = new TransformGroup(rotate);
16.
17.   translate.set(new Vector3f(0.1f, 0.0f, 0.0f));
18.   TransformGroup yoyoTGT1 = new TransformGroup(translate);
19.
20.   Cone cone1 = new Cone(0.6f, 0.2f);
21.   cone1.setAppearance(yoyoAppear);
22.
23.   yoyoBG.addChild(yoyoTGT1);
24.   yoyoTGT1.addChild(yoyoTGR1);
25.   yoyoTGR1.addChild(cone1);
26.
27.   translate.set(new Vector3f(-0.1f, 0.0f, 0.0f));
28.   TransformGroup yoyoTGT2 = new TransformGroup(translate);
29.
30.   rotate.rotZ(-Math.PI/2.0d);
31.   TransformGroup yoyoTGR2 = new TransformGroup(rotate);
32.
33.   Cone cone2 = new Cone(0.6f, 0.2f);
34.   cone2.setAppearance(yoyoAppear);
35.
36.   yoyoBG.addChild(yoyoTGT2);
37.   yoyoTGT2.addChild(yoyoTGR2);
38.   yoyoTGR2.addChild(cone2);
39.
40.   yoyoBG.compile();
41.
42.   } // end of ConeYoyo constructor
43.
44.   public BranchGroup getBG(){
45.   return yoyoBG;
46.  }
47.
48. } // end of class ConeYoyo

.�Geometr�as Primitivas

El �rbol de clases de la Figura 2-4 muestra Primitive como la superclase de Box, Cone, Cylinder, y Sphere. Define un n�mero de campos y m�todos comunes a estas clases, as� como los valores por defecto para los campos.

La clase Primitive proporciona una forma de compartir nodos componentes Geometry entre ejemplares de un primitivo del mismo tama�o. Por defecto, todos los primitivos del mismo tama�o comparte un nodo componente de geometr�a. Un ejemplo de un campo definido en la clase Primitive es el entero GEOMETRY_NOT_SHARED. Este campo especifica la geometr�a que se est� creando y que no ser� compartido con otros. Seleccionamos esta bandera para evitar que la geometr�a sea compartida entre primtivos de los mismos par�metros (es decir, esferas con r�dio 1).

myCone.setPrimitiveFlags(Primitive.GEOMETRY_NOT_SHARED);

Lista Parcial de M�todos Primitive

Paquete: com.sun.j3d.utils.geometry

Primitive desciende de Group y es la superclase de Box, Cone, Cylinder, y Sphere.

public void setNumVertices(int num)

Selecciona el n�mero total de v�rtices en este primitivo.

void setPrimitiveFlags(int fl)

Las banderas de Primitive son:

  • GEOMETRY_NOT_SHARED
    Se generan normalmente junto las posiciones.
  • GENERATE_NORMALS_INWARD
    Normalmente se lanzan junto con las superficies.
  • GENERATE_TEXTURE_COORDS
    Se generan las coordenadas de textura.
  • GEOMETRY_NOT_SHARED
    La geometr�a creada no se compartir� con ning�n otro nodo.
void setAppearance(int partid, Appearance appearance)

Selecciona la apariencia de una subparte dando un partid. Los objetos Box, Cone, y Cylinder est�n compuestos por m�s de un objeto Shape3D, cada uno potencialmente tiene su propio nodo Appearance. El valor usado para partid especifica el componente Appearance seleccionado.

void setAppearance()

Selecciona la apariencia principal del primitivo (todas las subpartes) a una apariencia blanca por defecto.

Otros constructores adicionales de Box, Cone, Cylinder, y Sphere permiten la especificaci�n de banderas Primitive en el momento de la creacci�n. Puedes consultar la especificaci�n del API Java 3D para m�s informaci�n.

.�Clases Matem�ticas

Para crear objetos visuales, se necesitan la clase Geometry y sus subclases. Muchas de �stas subclases describen primitivos basados en v�rtices, como puntos, l�neas y pol�gonos rellenos. Las subclases se ver�n en una pr�xima secci�n, pero antes veremos varias clases matem�ticas (Point*, Color*, Vector*, TexCoord*) usadas para especificar datos relacionados con los v�rtices

Nota: el asterisco usado arriba es un comod�n para representar variaciones en el nombre de la clases. Por ejemplo, Tuple* se refiere a todas las clases: Tuple2f, Tuple2d, Tuple3b, Tuple3f, Tuple3d, Tuple4b, Tuple4f, y Tuple4d. En cada caso el n�mero indica el n�mero de elementos del Tuple, y la letra indica el tipo de los datos. _f_ indica un tipo de coma flotante de simple precisi�n, _d_ indica un tipo de coma flotante de doble precisi�n, y _b_ es para bytes. Por eso Tuple3f es una clase que manipula valores en coma flotante de simple precisi�n.

Todas estas clases matem�ticas est�n en el paquete javax.vecmath.*. Este paquete define varias clases Tuple* como superclases gen�ricas abstractas. Otras clases m�s �tiles descienden de las clases Tuple. En la Figura 2-9, podemos ver algunas de las clases del �rbol.

Figura 2-9. �rbol de clases del paquete de clases matem�ticas.

Cada v�rtice de un objeto visual podr�a especificar hasta cuatro objetos javax.vecmath, representadno coordenadas, colores. superficies normales, y coordenadas de textura. Normalmente se usan las siguientes clases:

  • Point* (para coordenadas)
  • Color* (para colores)
  • Vector* (para superficies normales)
  • TexCoord* (para coordenadas de textura)

Observa que las coordenadas (objetos Point*) son necesarios para posicionar cada v�rtice. Los otros datos son opcionales, dependiendo de c�mo se renderice el primitivo. Por ejemplo, se podr�a definir un color (un objeto Color*) para cada v�rtice y los colores del primitive se interpolan entre los colores de los v�rtices. Si se permite la iluminaci�n, ser�n necesarias las superficies normales (y por lo tanto los objetos Vector*). Si se permite el mapeo de texturas, podr�an necesitarse las coordenadas de texturas.

(Los objetos Quat* representan 'quaternions', que s�lo se usan para transformaciones de matrices 3D avanzadas.)

Como todas las clases �tiles descienden de las clases abstractas Tuple*, es importante familiarizarse con sus constructores y m�todos:

Constructores de Tuple2f

Paquete: javax.vecmath

Las clases Tuple* casi nunca se utilizan directamente en programas Java pero proporcionan la base para las clases Point*, Color*, Vector*, y TexCoord*. En particular Tuple2f proporciona la base para Point2f, Color2f, y TexCoord2f. Los constructores listados aqu� est�n disponibles para estas subclases. Tuple3f y Tuple4f tienen un conjunto similar de constructores:

Tuple2f()

Construye e inicializa un objeto Tuple con las coordenadas (0,0).

Tuple2f(float x, float y)

Construye e inicializa un objeto Tuple con las coordenadas x e y especificadas.

Tuple2f(float[] t)

Construye e inicializa un objeto Tuple desde el array especificado.

Tuple2f(Tuple2f t)

Construye e inicializa un objeto Tuple desde los datos de otro objeto Tuple.

Tuple2f(Tuple2d t)

Construye e inicializa un objeto Tuple desde los datos de otro objeto Tuple.

Lista Parcial de M�todos de Tuple2f

Paquete: javax.vecmath

Las clases Tuple* casi nunca se utilizan directamente en programas Java pero proporcionan la base para las clases Point*, Color*, Vector*, y TexCoord*. En particular Tuple2f proporciona la base para Point2f, Color2f, y TexCoord2f. Los m�todos listados aqu� est�n disponibles para estas subclases. Tuple3f y Tuple4f tienen un conjunto similar de m�todos:

void set(float x, float y)
void set(float[] t)

Seleccionan el valor de este tuple desde los valores especificados.

boolean equals(Tuple2f t1)

Devuelven true si los datos del Tuple t1 son iguales a los datos correspondientes de este tuple.

final void add(Tuple2f t1)

Selecciona el valor de este tuple al vector suma de si mismo y Tuple t1.

void add(Tuple2f t1, Tuple2f t2)

Selecciona el valor de este tuple al vector suma de los tuples t1 y t2.

void sub(Tuple2f t1, Tuple2f t2)

Selecciona el valor de este tuple al vector resta de los tuples t1 y t2 (this = t1 - t2).

void sub(Tuple2f t1)

Selecciona el valor de este tuple al vector resta de su mismo menos t1.

void negate()

Niega el valor de este vector.

void negate(Tuple2f t1)

Selecciona el valor de este tuple a la negaci�n del tuple t1.

void absolute()

Selecciona todos los componentes de este tuple a sus valores absolutos.

void absolute(Tuple2f t)

Selecciona todos los componentes del tuple par�metros a sus valores absolutos, y sit�a los valores modificados en este tuple.

Hay sut�les, pero predecibles diferencias entre los constructores y m�todos de Tuple*, debido al n�mero y tipo de los datos. Por ejemplo, Tuple3d difiere de Tuple2f, porque tiene un m�todo constructor:

Tuple3d(double x, double y, double z);

que espera tres y no dos, parametros de pundo flotante de doble precision, no simple precisi�n.

Todas las clases Tuple* tienen miembros p�blicos. Para Tuple2*, hay x e y. Para Tuple3* los miembros son x, y, y z. Para Tuple4* los miembros son x, y, z, y w.

.�Clases Point

Los objetos Point* normalmente representan coordenadas de un v�rtice, aunque tambi�n pueden representar la posici�n de una imagen, fuente de un punto de luz, localizaci�n espacial de un sonido, u otro dato posicional. Los constructores de las clases Point* son muy similares a los de Tuple*, excepto en que devuelven objetos Point*.

Lista Parcial de M�todos de Point3f

Paquete: javax.vecmath

Las clases Point* descienden de las clases Tuple*. Cada ejemplar de las clases Point* representa un solo punto en un espacio de dos, tres o cuatro dimensiones. Adem�s de los m�todos de Tuple*, las clases Point* tienen m�todos adicionales, algunos de los cuales podemos ver aqu�:

float distance(Point3f p1)

Devuelve la distancia Euclideana entre este punto y el punto p1.

float distanceSquared(Point3f p1)

Devuelve el cuadrado de la distanci� Euclideana entre este punto y el punto p1.

float distanceL1(Point3f p1)

Devuelve la distancia L (Manhattan) entre este punto y el punto p1. La distancia L es igual a= abs(x1 - x2) + abs(y1 - y2) + abs(z1 - z2)

.�Clases Color

Los objetos Color* representan un color, que puede ser para un v�rtice, propiedad de un material, niebla, u otro objeto visual. Los colores se especifican con Color3* o Color4*, y s�lo para datos de byte o coma flotante de simple precisi�n. Los objetos Color3* especifican un color como una combinaci�n de valores rojo, verde y azul (RGB). Los objetos Color4* especifican un valor de transpariencia, adem�s del RGB. (por defecto, los objetos Color3* son opacos). Para los tipos de datos de tama�o byte, los valores de colores van desde 0 hasta 255 inclusives. Para tipos de datos de coma flotante de simple precisi�n, los valores van entre 0,0 y 1,0 inclusives.

De nuevo, los constructores para las clases Color* son similares a los de Tuple*, excepto en que devuelven objetos Color*. Las clases Color* no tienen m�todos adicionales, por eso s�lo tratan con los m�todos que heredan de sus superclases Tuple*.

Algunas veces es conveniente crear constantes para los colores que se usan repetidamente en la creacci�n de objetos visuales. Por ejemplo,

Color3f rojo = new Color3f(1.0f, 0.0f, 0.0f);

ejemplariza el objeto Color3f rojo que podr�a usarse varias veces. Podr�a ser �til crear una clase que contenga varias cosntantes de colores. Abajo podemos ver un ejemplo de una de estas clases que aparece en el Fragmento de C�digo 2-1.

1. import javax.vecmath.*;
2.
3. class ColorConstants{
4.     public static final Color3f rojo = new Color3f(1.0f,0.0f,0.0f);
5.     public static final Color3f verde = new Color3f(0.0f,1.0f,0.0f);
6.     public static final Color3f azul = new Color3f(0.0f,0.0f,1.0f);
7.     public static final Color3f amarillo = new Color3f(1.0f,1.0f,0.0f);
8.     public static final Color3f cyan = new Color3f(0.0f,1.0f,1.0f);
9.     public static final Color3f magenta = new Color3f(1.0f,0.0f,1.0f);
10.   public static final Color3f blanco = new Color3f(1.0f,1.0f,1.0f);
11.   public static final Color3f negro = new Color3f(0.0f,0.0f,0.0f);
12. }

.�Clases Vector

Los objetos Vector* frecuentemente representan superficies normales en v�rtices aunque tambi�n pueden representar la direcci�n de una fuente de luz o de sonido. De nuevo, los constructores de las clases Vector* son similares a los de Tuple*. Sin embargo, los objetos Vector* a�aden muchos m�todos que no se encuentran en las clases Tuple*.

Lista Parcial de M�todos de Vector3f

Paquete: javax.vecmath

Las clases Vector* descienden de las clases Tuple*. Cada ejemplar de las clases Vector* representa un solo vector en un espacio de dos, tres o cuatro dimensiones. Adem�s de los m�todos de Tuple*, las clases Vector* tienen m�todos adicionales, algunos de los cuales podemos ver aqu�:

float length()

Devuelve la longitud de este vector.

float lengthSquared()

Devuelve el cuadrado de la longitud de este vector.

void cross(Vector3f v1, Vector3f v2)

Seleccciona este vector para que sea el producto cruzado de los vectores v1 y v2.

float dot(Vector3f v1)

Calcula y devuelve el punto del producto de este vector y el vector v1.

void normalize()

Normaliza este vector.

void normalize(Vector3f v1)

Selecciona el valor de este vector a la normalizaci�n del vector v1.

float angle(Vector3f v1)

Devuelve el �ngulo en radianes entre este vector y el vectorv1, el valor devuelto est� restringido al ango [0,PI].

.�Clases TexCoord

Hay s�lo dos clases TexCoord* que pueden usarse para representar las coordenadas de textura de un v�rtice: TexCoord2f y TexCoord3f. TexCoord2f mantiene las coordenadas de textura como una pareja de coordenadas (s, t); TexCoord3f como un trio (s, t, r).

Los constructores para las clases TexCoord* tambi�n son similares a los de Tuple*. como las clases Color*, las clases TexCoord* tampoco tienen m�todos adicionales, por eso s�lo tratan con los m�todos que heredan de sus superclases.

.�Clases Geometry

En los gr�ficos 3D por ordenador, todo, desde el m�s sencillo tri�ngulo al m�s complicado de los modelos Jumbo, est� modelado y renderizado con datos basados en v�rtices. Con Java 3D, cada objeto Shape3D deber�a llamar a su m�todo setGeometry() para referenciar uno y s�lo uno objeto Geometry. Para ser m�s preciso, Geometry es una superclase abstracta, por eso los objetos referenciados son ejemplares de una de sus subclases.

Estas subclases se dividen en tres categor�as principales:

  • Geometr�a basada en v�rtices no indexados (cada vez que se renderiza un objeto visual, sus v�rtices s�lo podr�an usarse una vez)
  • Geometr�a basada en v�rtices indexados (cada vez que se renderiza un objeto visual, sus v�rtices se podr�an reutilizar)
  • Otros objetos visuales (las clases Raster, Text3D, y CompressedGeometry)

Esta secci�n cubre las dos primeras categor�as. El �rbol de clases de Geometry y sus subclases se muestran en la Figura 2-10:

Figura 2-10. �rbol de clases de Geometry.

.�Clase GeometryArray

Como se podr�a deducir de los nombres de las clases, las subclases de Geometry podr�an usarse para especificar puntos, l�neas y pol�gonos rellenos (tri�ngulos y cuadril�teros). Estos primitivos basados en v�rtices son subclases de la clases abstracta GeometryArray, que indica que cada una tiene un array que mantine los datos de los v�rtices.

Por ejemplo, si se usa un objeto GeometryArray para especificar un tri�ngulo, se define un array de tres elementos: un elemento para cada v�rtice. Cada elemento de este array mantiene la localizaci�n de las coordenbadas para su v�rtice (que puede estar definido con un objeto Point* o similar). Adem�s de la localizaci�n de las coordenadas, se pueden definir otros tres arrays opcionales para almacenar el color, la superficie normal, y las coordenadas de textura. Estos arrays que contienen las coordenadas, los colores, las superficies normales y las coordenadas de texturas, son los "arrays de datos".

Hay tres pasos en la vida de un objeto GeometryArray:

  1. Construcci�n de un objeto vac�o.
  2. Rellenar el objeto con datos.
  3. Asociar (referenciar) el objeto desde (uno o m�s) objetos Shape3D.

.�Paso 1: Construcci�n de un objeto GeometryArray vac�o

Cuando se construye por primera vez un objeto GeometryArray, se deben definir dos cosas:

  • el n�mero de v�rtices (arrays de elementos) necesarios.
  • el tipo de datos (coordenadas de localizaci�n, color, superficie normal, y/o coordenadas de textura) a almacenar en cada v�rtice. Esto se llama formato del v�rtice.

Hay un s�lo constructor para GeometryArray:

Constructor de GeometryArray

GeometryArray(int vertexCount, int vertexFormat)

Construye un objeto GeometryArray vac�o con el n�mero de v�rtices y su formato especificado. Se pueden a�adir banderas "OR" para describir los datos de cada v�rtice. Las constantes usasas para especificar el formato son:

  • COORDINATES:
    Especifica que este array de v�rtice contiene coordenadas. Es obligatorio.
  • NORMALS:
    Especifica que este array de v�rtice contiene superficies normales.
  • COLOR_3:
    Especifica que este array de v�rtice contiene colores sin transparencia.
  • COLOR_4:
    Especifica que este array de v�rtice contiene colores con transparencia.
  • TEXTURE_COORDINATE_2:
    Especifica que este array de v�rtice contiene coordenadas de textura 2D.
  • TEXTURE_COORDINATE_3:
    Especifica que este array de v�rtice contiene coordenadas de textura 3D.

Por cada bandera seleccionada, se crea internamente en el objeto GeometryArray su correspondiente array. Cada uno de estos arrays tiene el tama�o vertexCount.

Veamos c�mo trabaja este constructor, pero primero recordemos que GeometryArray es una clase abstracta. Por lo tanto, realmente llamamos al constructor de una de sus subclases, por ejemplo LineArray. (Un objeto LineArray describe un conjunto de v�rtices, y cada dos v�rtices definen los puntos finales de una l�nea. El constuctor y otros m�todos de LineArray son muy similares a los de su superclase GeometryArray. LineArray se explica con m�s detalle m�s adelante.)

El Fragmento de C�digo 2-4 muestra la clase Axis del programa AxisApp.java que usa varios objetos LineArray para dibujar l�neas que representan los ejes X, Y y Z. El objeto axisXlines, crea un objeto con dos v�rtices (para dibujar una l�nea entre ellos), con s�lo los datos de las coordenadas de localizaci�n. El objeto axisYLines tambi�n tiene dos v�rtices, pero permite color RGB, as� como las coordenadas de posici�n de cada v�rtice. Por lo tanto, la l�nea del eje Y podr�a dibujarse con colores interpolados desde un v�rtice hasta el otro. Finalmente, el objeto axisZLines tiene diez v�rtices con coordenadas y datos de color para cada v�rtice. Se podr�an dibujar cinco l�neas con colores interpolados, una l�nea por cada pareja de v�rtices. Observa el uso de la operaci�n "OR" para los formatos de los v�rtices de los ejes Y y Z

Fragmento de c�digo 2-4, Consctructores de GeometryArray.
1.     // construye un objeto que representa el eje X
2.     LineArray axisXLines= new LineArray (2, LineArray.COORDINATES);
3.
4.     // construye un objeto que representa el eje Y
5.     LineArray axisYLines = new LineArray(2, LineArray.COORDINATES
6.             | LineArray.COLOR_3);
7.
8.     // construye un objeto que representa el eje Z
9.     LineArray axisZLines = new LineArray(10, LineArray.COORDINATES
10.           | LineArray.COLOR_3);

�Cuidado! la clase Axis de AxisApp.java es diferente de la clase Axis definida en Axis.java, que s�lo usa un objeto LineArray. Debemos asegurarnos de coger la clase correcta.

.�Paso 2: Rellenar con Datos el Objeto GeometryArray

Despu�s de construir el objeto GeometryArray, asignamos valores a los arrays, correspondiendo a los formatos de los v�rtices asignados. Esto se podr�a hacer v�rtice por v�rtice, o usando un array para aisgnar datos a muchos v�rtices con una s�la llamada de m�todo. Los m�todos disponibles son:

Lista Parcial de M�todos de GeometryArray

GeometryArray es la superclase para PointArray, LineArray, TriangleArray, QuadArray, GeometryStripArray, y IndexedGeometryArray.

void setCoordinate(int index, float[] coordinate)
void setCoordinate(int index, double[] coordinate)
void setCoordinate(int index, Point* coordinate)

Selecciona las coordenadas asociadas con el v�rtice en el �ndice especificado para este objeto.

void setCoordinates(int index, float[] coordinates)
void setCoordinates(int index, double[] coordinates)
void setCoordinates(int index, Point*[] coordinates)

Selecciona las coordenadas asociadas con los v�rtices empezando por el �ndice especificado para este objeto.

void setColor(int index, float[] color)
void setColor(int index, byte[] color)
void setColor(int index, Color* color)

Selecciona el color asociado con el v�rtice en el �ndice especificado para este objeto.

void setColors(int index, float[] colors)
void setColors(int index, byte[] colors)
void setColors(int index, Color*[] colors)

Selecciona los colores asociados con los v�rtices empezando por el �ndice especificado para este objeto.

void setNormal(int index, float[] normal)
void setNormal(int index, Vector* normal)

Selecciona la superficie normal asociada con el v�rtice en el �ndice especificado para este objeto

void setNormals(int index, float[] normals)
void setNormals(int index, Vector*[] normals)

Selecciona las superficies normales asociadas con los v�rtices empezando por el �ndice especificado para este objeto.

void setTextureCoordinate(int index, float[] texCoord)
void setTextureCoordinate(int index, Point* coordinate)

Selecciona la coordenada de textura asociada con el v�rtice en el �ndice especificado para este objeto.

void setTextureCoordinates(int index, float[] texCoords)
void setTextureCoordinates(int index, Point*[] texCoords)

Selecciona las coordenadas de textura asociadas con los v�rtices empezando por el �ndice especificado para este objeto.

El Fragmento de C�digo 2-5 usa los m�todos de GeometryArray para almacenar coordenadas y colores en los objetos LineArray, El objeto axisXLines s�lo llama al m�todo setCoordinate() para almacenar los datos de las coordenadas de posici�n. El objeto axisYLines llama tanto a setColor() y setCoordinate() para cargar los valores del color RGB y las coordenadas de posici�n. Y el objeto axisZLines llama diez veces a setCoordinate() una para cada v�rtice y llama una vez a setColors() para cargar todos los v�rtices con una sola llamada:

Fragmento de c�digo 2-5, Almacenar Datos en un Objeto GeometryArray.
1.     axisXLines.setCoordinate(0, new Point3f(-1.0f, 0.0f, 0.0f));
2.     axisXLines.setCoordinate(1, new Point3f( 1.0f, 0.0f, 0.0f));
3.
4.     Color3f red = new Color3f(1.0f, 0.0f, 0.0f);
5.     Color3f green = new Color3f(0.0f, 1.0f, 0.0f);
6.     Color3f blue = new Color3f(0.0f, 0.0f, 1.0f);
7.     axisYLines.setCoordinate(0, new Point3f( 0.0f,-1.0f, 0.0f));
8.     axisYLines.setCoordinate(1, new Point3f( 0.0f, 1.0f, 0.0f));
9.     axisYLines.setColor(0, green);
10.   axisYLines.setColor(1, blue);
11.
12.   axisZLines.setCoordinate(0, z1);
13.   axisZLines.setCoordinate(1, z2);
14.   axisZLines.setCoordinate(2, z2);
15.   axisZLines.setCoordinate(3, new Point3f( 0.1f, 0.1f, 0.9f));
16.   axisZLines.setCoordinate(4, z2);
17.   axisZLines.setCoordinate(5, new Point3f(-0.1f, 0.1f, 0.9f));
18.   axisZLines.setCoordinate(6, z2);
19.   axisZLines.setCoordinate(7, new Point3f( 0.1f,-0.1f, 0.9f));
20.   axisZLines.setCoordinate(8, z2);
21.   axisZLines.setCoordinate(9, new Point3f(-0.1f,-0.1f, 0.9f));
22.
23.   Color3f colors[] = new Color3f[9];
24.   colors[0] = new Color3f(0.0f, 1.0f, 1.0f);
25.   for(int v = 0; v < 9; v++)
26.   colors[v] = red;
27.   axisZLines.setColors(1, colors);

El color por defecto para los v�rtices de un objeto GeometryArray es blanco, a menos que especifiquemos COLOR_3 o COLOR_4 en el formato del v�rtice. Cuando se especifica cualquiera de estos valores, el color por defecto del v�rtice es negro. Cuando se renderizan l�neas o pol�gonos rellenos con diferentes colores en cada v�rtice, los colores se sombrean (interpolan) entre los v�rtices usando un sombreado Gouraud.

.�Paso 3: Hacer que los Objetos Shape3D Referencien a los Objetos GeometryArray

Finalmente, el Fragmento de C�digo 2-6 muestra c�mo se referencian los objetos GeometryArray por objetos Shape3D recien creados. A su vez, los objetos Shape3D se a�aden a un BranchGroup, que en alg�n lugar se a�ade al escenario gr�fico general. (Al contrario que los objetos GeometryArray, que son NodeComponents, Shape3D es una subclase de Node, por eso pueden ser a�adidos como hijos al escenario gr�fico.)

Fragmento de c�digo 2-6, Objetos GeometryArray referenciados por objetos Shape3D.
1.     axisBG = new BranchGroup();
2.
3.     axisBG.addChild(new Shape3D(axisYLines));
4.     axisBG.addChild(new Shape3D(axisZLines));

La Figura 2-11 muestra el escenario gr�fico parcial creado por la clase Axis en AxisApp.java.

Figura 2-11, La clase Axis de AxisApp.java crea este Escenario Gr�fico.

.�Subclases de GeometryArray

Como se explic� en la secci�n anterior, la clase GeometryArray es una superclase abstracta para subclases m�s �tiles, como LineArray. La Figura 2-12 muestra el �rbol de subclases de GeometryArray. La principal distinci�n entre estas subclases es c�mo el renderizador Java 3D decide renderizar sus v�rtices.

Figura 2-12, Subclases no indexadas de GeometryArray.

La Figura 2-13 muestra ejemplos de las cuatro subclases de GeometryArray: PointArray, LineArray, TriangleArray, y QuadArray (las �nicas que no son tambi�n subclases de GeometryStripArray). En esta figura, los tres conjuntos m�s a la izquierda muestran los mismos seis v�rtices renderizando seis puntos, tres l�neas, o dos tri�ngulos. La cuarta imagen muestra cuatro v�rtices difiniendo un cuadril�tero. Observa que ninguno de los v�rtices est�n compartido: cada l�nea o pol�gono relleno se renderiza independiente,ente de cualquier otra.

Figura 2-13, Subclases de GeometryArray.

Por defecto, se rellena el interior de los tri�ngulos y cuadril�teros. En la �ltima secci�n, aprenderemos los atributos que pueden influenciar en el modo de renderizado de los primivitivos rellenos.

Estas cuatro subclases heredan sus constructores y m�todos de GeometryArray. Abajo podemos ver sus constructores, para sus m�todos, podemos volver atr�s a la lista de los m�todos de GeometryArray.

Constructores de Subclases de GeometryArray

Construyen objetos vac�os con el n�mero de v�rtices especificados y el formato de los v�rtices. Se pueden a�adir banderas "OR" para describir los datos de cada v�rtice. Las banderas de formato son las mismas que las definidas en la superclase GeometryArray.

PointArray(int vertexCount, int vertexFormat)
LineArray(int vertexCount, int vertexFormat)
TriangleArray(int vertexCount, int vertexFormat)
QuadArray(int vertexCount, int vertexFormat)

Para ver el uso de estos constructores y m�todos, podemos volver a cualquiera de los fragmentos de c�digo 2-4, 2-5 o 2-6, que usan objetos LineArray .

Si est�mos dibujando cuadril�teros, debemos tener cuidado de no crear los v�rtices en una geometr�a c�ncava, auto-intereseccionada, o geometr�a no plana. Si lo hacemos, podr�an no renderizarse apropiadamente.

.�Subclases de GeometryStripArray

Las cuatro subclases de GeometriArray descritas anteriormente no permite reutilizar v�rtices. Algunas configuraciones geom�tricas invitan a reutilizar los v�rtices, por eso podr�an resultar clases especializadas para un mejor rendimiento del renderizado.

GeometryStripArray es una clase abstracta de la que se derivan tipos primitivos (para crear l�neas y superficies compuestas). GeometryStripArray es la superclase de LineStripArray, TriangleStripArray, y TriangleFanArray. La Figura 2-14 muestra un ejemplar de cada tipo y c�mo se reutilizan los v�rtices. LineStripArray renderiza las l�neas conectadas. TriangleStripArray resulta en tri�ngulos que comparten un lado, reusando el v�rtice renderizado m�s recientemente. TriangleFanArray reutiliza el primer v�rtice en su l�mina.

Figura 2-14, Subclases de GeometryStripArray.

GeometryStripArray tiene un constructor distinto al de GeometryArray. El constructor GeometryStripArray tiene un tercer par�metro, que es un array contador de v�rtices para cada l�mina, permitiendo que un s�lo objeto mantenga varias l�minas. (GeometryStripArray tambi�n presenta un par de m�todos de consulta, getNumStrips() y getStripVertexCounts(), que raramente se usan.)

Constructores de Subclases de GeometryStripArray

Construyen objetos vac�os con el n�mero de v�rtices especificados y el formato de los v�rtices. Se pueden a�adir banderas "OR" para describir los datos de cada v�rtice. Las banderas de formato son las mismas que las definidas en la superclase GeometryArray. Se soportan m�ltiples l�minas. La suma de los contadores de v�rtices para todas las l�minas (del array stripVertexCounts) debe ser igual al contador de todos los v�rtices (vtxCount).

LineStripArray(int vtxCount, int vertexFormat, int stripVertexCounts[])
TriangleStripArray(int vtxCount, int vertexFormat, int stripVertexCounts[]))
TriangleFanArray(int vtxCount, int vertexFormat, int stripVertexCounts[]))

Observa que Java 3D no soporta primitivos rellenos con m�s de cuatro lados. El programador es responsable de usar mosaicos para descomponer pol�gonos m�s complejos en objetos Java 3D. La clases de utilidad Triangulator convierte pol�gonos complejos en tri�ngulos

La clase Triangulator

Paquete: com.sun.j3d.utils.geometry

Se usa para convertir pol�gonos no tri�ngulares en tri�ngulos para renderizarlos con Java 3D. Los pol�gonos pueden ser c�ncavos, no planos y pueden contener agujeros (puedes ver GeometryInfo.setContourCounts()). Los pol�gonos no planos se proyectan al plano m�s cercano.

Sumario de Constructores

Triangulator()

Crea un objeto Triangulator.

Sumario de M�todos

void triangulate(GeometryInfo ginfo)

Esta rutina convierte el objeto GeometryInfo desde un tipo primitivo POLYGON_ARRAY a un tipo primitivo TRIANGLE_ARRAY us�ndo t�cnicas de descomposici�n de pol�gonos.

Par�metros:

  • ginfo - el objeto com.sun.j3d.utils.geometry.GeometryInfo a triangular.

Ejemplo de uso:

Triangulator tr = new Triangulator();
tr.triangulate(ginfo); // ginfo contains the geometry
shape.setGeometry(ginfo.getGeometryArray()); // shape is a Shape3D

El c�digo del Yo-yo Demuestra TriangleFanArray

El objeto Yoyo del programa YoyoApp.java muestra c�mo usar un objeto TriangleFanArray para modelar la geometr�a de un yo-yo. El TriangleFanArray contiene cuatro abanicos: dos caras exteriores (discos circulares) y dos caras internas (conos). S�lo se necesita un objeto TriangleFanArray para representar los cuatro abanicos.

La Figura 2-15 muestra tres renderizaciones del TriangleFanArray. La primera vista muestra su renderizado por defecto, como pol�gonos rellenos blancos. Sin embargo, es d�ficil ver los detalles, especialmente la localizaci�n de los v�rtices. Para mostrar mejor los tri�ngulos, las otras dos vistas muestran el TriangleFanArray con sus v�rtices conectados con l�neas. Para renderizar lo que ser�an los pol�gonos rellenos con l�neas, puedes ver la clases PolygonAttributes m�s adelante.

Figura 2-15, tres vistas del Yo-yo.

En el Fragmento de C�digo 2-7 el m�todo yoyoGeometry() crea y devuelve el TriangleFanArray deseado. Las l�neas 15-18 calculan los puntos centrales para los cuatro abanicos. Cada abanico tiene 18 v�rtices, que se calculan en las l�neas 20-28. Las l�neas 30-32 construyen el objeto TriangleFanArray vac�o, y la l�nea 34 es donde las coordenadas calculadas pr�viamente (en las l�neas 15-28) se almacenan en el objeto.

Fragmento de C�digo 2-7, el metodo yoyoGeometry() crea un objeto TriangleFanArray
1. private Geometry yoyoGeometry() {
2.
3.     TriangleFanArray tfa;
4.     int N = 17;
5.     int totalN = 4*(N+1);
6.     Point3f coords[] = new Point3f[totalN];
7.     int stripCounts[] = {N+1, N+1, N+1, N+1};
8.     float r = 0.6f;
9.     float w = 0.4f;
10.   int n;
11.   double a;
12.   float x, y;
13.
14.   // set the central points for four triangle fan strips
15.   coords[0*(N+1)] = new Point3f(0.0f, 0.0f, w);
16.   coords[1*(N+1)] = new Point3f(0.0f, 0.0f, 0.0f);
17.   coords[2*(N+1)] = new Point3f(0.0f, 0.0f, 0.0f);
18.   coords[3*(N+1)] = new Point3f(0.0f, 0.0f, -w);
19.
20.   for (a = 0,n = 0; n < N; a = 2.0*Math.PI/(N-1) * ++n){
21.      x = (float) (r * Math.cos(a));
22.      y = (float) (r * Math.sin(a));
23.
24.      coords[0*(N+1)+N-n] = new Point3f(x, y, w);
25.      coords[1*(N+1)+n+1] = new Point3f(x, y, w);
26.      coords[2*(N+1)+N-n] = new Point3f(x, y, -w);
27.      coords[3*(N+1)+n+1] = new Point3f(x, y, -w);
28.   }
29.
30.   tfa = new TriangleFanArray (totalN,
31.   TriangleFanArray.COORDINATES,
32.       stripCounts);
33.
34.   tfa.setCoordinates(0, coords);
35.
36.   return tfa;
37.} // end of method yoyoGeometry in class Yoyo

El yo-yo totalmente blanco es s�lo un punto de arranque. La Figura 2-16 muestra un objeto similar, modificado para incluir colores en cada v�rtice. El m�todo yoyoGeometry() modificado, que incluye colores en el objeto TriangleFanArray, se muestra en el Fragmento de C�digo 2-8. Las l�neas 23-26, 36-39 y 46 especifician los valores de color para cada v�rtice.

Existen m�s posibilidades para especificar la apariencia de un objeto visual a trav�s del uso de luces, texturas, y propiedades de materiales de un objeto visual.

Fragmento de C�digo 2-8, M�todo yoyoGeometry() Modificado para a�adir colores
1. private Geometry yoyoGeometry() {
2.
3.     TriangleFanArray tfa;
4.     int N = 17;
5.     int totalN = 4*(N+1);
6.     Point3f coords[] = new Point3f[totalN];
7.     Color3f colors[] = new Color3f[totalN];
8.     Color3f red = new Color3f(1.0f, 0.0f, 0.0f);
9.     Color3f yellow = new Color3f(0.7f, 0.5f, 0.0f);
10.   int stripCounts[] = {N+1, N+1, N+1, N+1};
11.   float r = 0.6f;
12.   float w = 0.4f;
13.   int n;
14.   double a;
15.   float x, y;
16.
17.   // set the central points for four triangle fan strips
18.   coords[0*(N+1)] = new Point3f(0.0f, 0.0f, w);
19.   coords[1*(N+1)] = new Point3f(0.0f, 0.0f, 0.0f);
20.   coords[2*(N+1)] = new Point3f(0.0f, 0.0f, 0.0f);
21.   coords[3*(N+1)] = new Point3f(0.0f, 0.0f, -w);
22.
23.   colors[0*(N+1)] = red;
24.   colors[1*(N+1)] = yellow;
25.   colors[2*(N+1)] = yellow;
26.   colors[3*(N+1)] = red;
27.
28.   for(a = 0,n = 0; n < N; a = 2.0*Math.PI/(N-1) * ++n){
29.      x = (float) (r * Math.cos(a));
30.      y = (float) (r * Math.sin(a));
31.      coords[0*(N+1)+n+1] = new Point3f(x, y, w);
32.      coords[1*(N+1)+N-n] = new Point3f(x, y, w);
33.      coords[2*(N+1)+n+1] = new Point3f(x, y, -w);
34.      coords[3*(N+1)+N-n] = new Point3f(x, y, -w);
35.
36.      colors[0*(N+1)+N-n] = red;
37.      colors[1*(N+1)+n+1] = yellow;
38.      colors[2*(N+1)+N-n] = yellow;
39.      colors[3*(N+1)+n+1] = red;
40.  }
41.   tfa = new TriangleFanArray (totalN,
42.         TriangleFanArray.COORDINATES|TriangleFanArray.COLOR_3,
43.         stripCounts);
44.
45.   tfa.setCoordinates(0, coords);
46.   tfa.setColors(0,colors);
47.
48.   return tfa;
49. } // end of method yoyoGeometry in class Yoyo

Habr�s observado las diferencias entre las l�neas 36 a 39. El c�digo se ha escrito para hacer la cara frontal de cada tri�ngulo en la geometr�a la parte exterior del yo-yo.

Figura 2-16, Yo-yo con Pol�gonos Rellenos Coloreados

.�Subclases de IndexedGeometryArray

Las subclases de GeometryArray descritas anteriormente declaran los v�rtices de forma borrosa. Solo las subclases de GeometryStripArray tienen incluso limitada la reutilizaci�n e v�rtices. Muchos objetos geom�tricos invitan a la reutilizaci�n de v�rtices. Por ejemplo, para definir un cubo, cada uno de sus ocho v�rtices se usa por tres diferentes cuadrados. En el peor de los casos, un cubo requiere especificar 24 v�rtices, aunque s�lo ocho son realmente necesarios (16 de los 24 son redundantes).

Los objetos IndexedGeometryArray proporcionan un nivel de extra de indirecci�n, por eso se puede evitar los v�rtices redundantes. Todav�a se deben proporcionar los arrays de informaci�n basada en v�rtices, pero los v�rtices se pueden almacenar en cualquier orden, y cualquier v�rtice se puede reutilizar durante el renderizado. A estos arrays que contienen informaci�n sobre las coordenadas, el color, etc. se les llama "Arrays de datos".

Sin embargo, los objetos IndexedGeometryArray tambi�n necesitan arrays adicionales ("arrays de �ndices") que contienen �ndices a los "arrays de datos". Hay hasta cuatro "arrays de �ndice": �ndices de coordenadas, �ndices de colores, �ndices de superficies normales, e �ndices de coordenadas de textura, que cooresponden con los "arrays de datos". El n�mero de arrays de �ndices es siempre igual al n�mero de arrays de datos. El n�mero de elementos en cada array de �ndice es el mismo y normalmente mayor que el n�mero de elementos en cada array de datos.

El "array de �ndices" podr�a tener m�ltiples referencias al mismo v�rtice en el "array de datos". Los valores en estos "arrays de �ndices" determinan el orden en que se accede a los datos del v�rtice durante el renderizado. La Figura 2-17 muestra como ejemplo la relaci�n entre los arrays de �ndice y de coordenadas para un cubo.

Merece la pena mencionar que hay que pagar un precio por la reutilizaci�n de los v�rtices proporcionada por la geometr�a indexada - lo pagamos en rendimiento. El indexado de geometr�as en el momento de la renderizaci�n a�ade m�s trabajo al proceso de renderizado. Si el rendimiento es un problema, debemos usar l�minas siempre que sea posible y evitar la geometr�a indexada. La geometr�a indexada es �til cuando la velocidad no es cr�tica y tenemos alguna memoria que ganar us�ndola, o cuando la indexaci�n proporciona programaci�n de conveniencia.

Figura 2-17, Arrays de �ndices y de Datos para un Cubo

Las subclases de IndexedGeometryArray son paralelas a las subclases de GeometryArray. En la Figura 2-18 podemos ver el �rbol de herencia de IndexedGeometryArray.

Figura 2-18, Subclases de IndexedGeometryArray

Los constructores para IndexedGeometryArray, IndexedGeometryStripArray, y sus subclases son similares a los constructores de GeometryArray y GeometryStripArray. Las clases de datos indexados tienen un par�metro adicional para definir c�antos �ndices se usan para describir la geometr�a (el n�mero de elemento en el array de �ndices).

Constructores de Sublcases de IndexedGeometryArray

Construyen un objeto vac�o con el n�mero de v�rtices especificado, el formato de los v�rtices, y el n�mero de �ndices en este array.

IndexedGeometryArray(int vertexCount, int vertexFormat, int indexCount)
IndexedPointArray(int vertexCount, int vertexFormat, int indexCount)
IndexedLineArray(int vertexCount, int vertexFormat, int indexCount)
IndexedTriangleArray(int vertexCount, int vertexFormat, int indexCount)
IndexedQuadArray(int vertexCount, int vertexFormat, int indexCount)

Constructores de Subclases de IndexedGeometryStripArray

Construye un objeto vac�o con el n�mero de vertices especificado, el formado de los v�rtices, el n�mero de �ndices de este array, y un array contador de v�rtices por cada l�mina.

IndexedGeometryStripArray(int vc, int vf, int ic, int stripVertexCounts[]))
IndexedLineStripArray(int vc, int vf, int ic, int stripVertexCounts[]))
IndexedTriangleStripArray(int vc, int vf, int ic, int stripVertexCounts[]))
IndexedTriangleFanArray(int vc, int vf, int ic, int stripVertexCounts[]))

IndexedGeometryArray, IndexedGeometryStripArray, y sus subclases heredan m�todos desde GeometryArray y GeometryStripArray para cargar los "arrays de datos". Las clases de datos indexados han a�adido m�todos para cargar �ndices dentro de los "arrays de �ndices".

Lista Parcial de M�todos de IndexedGeometryArray

void setCoordinateIndex(int index, int coordinateIndex)

Selecciona el �ndice de coordenada asociado con el v�rtice en el �ndice especificado para este objeto.

void setCoordinateIndices(int index, int[] coordinateIndices)

Selecciona los �ndices de coordenadas asociados con los v�rtices que empiezan en el �ndice especificado para este objeto.

void setColorIndex(int index, int colorIndex)

Selecciona el �ndice de color asociado con el v�rtice en el �ndice especificado para este objeto.

void setColorIndices(int index, int[] colorIndices)

Selecciona los �ndices de colores asociados con los v�rtices que empiezan en el �ndice especificado para este objeto.

void setNormalIndex (int index, int normalIndex)

Selecciona el �ndice de superficie normal asociado con el v�rtice en el �ndice especificado para este objeto.

void setNormalIndices (int index, int[] normalIndices)

Selecciona los �ndices de superficies normales asociados con los v�rtices que empiezan en el �ndice especificado para este objeto.

void setTextureCoordinateIndex (int index, int texCoordIndex)

Selecciona el �ndice de coordenada de textura asociado con el v�rtice en el �ndice especificado para este objeto.

void setTextureCoordinateIndices (int index, int[] texCoordIndices)

Selecciona los �ndices de coordenadas texturas asociados con los v�rtices que empiezan en el �ndice especificado para este objeto.

.�Axis.java es un ejemplo de IndexedGeometryArray

El fichero Axis.java define el objeto visual Axis muy �til para dibujar los ejes y el origen de un universo virtual. Tambi�n sirve como ejemplo de geometr�a indexada.

El objeto Axis define 18 v�rtices y 30 �ndices para especificar 15 l�neas. Hay cinco l�neas por eje para crear una sencilla flecha 3D.

.�Atributos y Apariencia

Los objetos Shape3D podr�an referenciar tanto a objetos Geometry y Appearance. Como se explic� anteriormente, el objeto Geometry especifica la informaci�n para cada v�rtice de un objeto visual. La informaci�n por v�rtices de un objeto Geometry puede especificar el color de los objetos visuales. Los datos de un objeto Geometry normalmente son insuficientes para describir totalmente c�mo es un objeto. En muchos casos, tambi�n se necesita un objeto Appearance.

Un objeto Appearance no contiene informaci�n sobre c�mo debe aparecer un objeto Shape3D, pero si sabe donde encontrar esos datos. Un objeto Appearance (ya que es una subclase de NodeComponent) podr�a referenciar varios objetos de otras subclases de la clase abstracta NodeComponent. Por lo tanto la informaci�n que describe la apariencia de un primitivo geom�trico se dice que est� almacenada dentro de un "paquete de apariencia", como se ve en la Figura 2-19.

Figura 2-19, un Paquete de Apararencia

Un objeto Appearance puede referenciar a varias subclases diferentes de NodeComponent llamados objetos de atributos de apariencia, incluyendo:

  • PointAttributes
  • LineAttributes
  • PolygonAttributes
  • ColoringAttributes
  • TransparencyAttributes
  • RenderingAttributes
  • Material
  • TextureAttributes
  • Texture
  • TexCoordGeneration

A un objeto Appearance con objetos atributos se le llama un paquete de apariencia. Para referenciar cualquiera de estos nodos componentes, un objeto Appearance tiene un m�todo con un nombre �bvio. Por ejemplo, para que un objeto Appearance se refiera a un objeto ColoringAttributes, se usa el m�todo Appearance.setColoringAttributes(). Un sencillo ejemplo de c�digo de parecer�a est� en Fragmento de c�digo 2-9.

Fragmento de C�digo 2-9, Usando objetos Appearance y ColoringAttributes de NodeComponent .
1. ColoringAttributes ca = new ColoringAttributes();
2. ca.setColor (1.0, 1.0, 0.0);
3. Appearance app = new Appearance();
4. app.setColoringAttributes(ca);
5. Shape3D s3d = new Shape3D();
6. s3d.setAppearance (app);
7. s3d.setGeometry (someGeomObject);

En la Figura 2-20 podemos ver el escenario gr�fico resultante de el c�digo anterior.

Figura 2-20, Paquete de Apariencia creado por el Fragmento de C�digo 2-9.

.�NodeComponent Appearance

Los dos siguientes bloques de referencia listan los constructores y otros m�todos de la clase Appearance.

Constructor de Appearance

El constructor por defecto de Appearance crea un objeto con todas las referencias a objetos inicializadas a null. Los valores por defecto, para componentes con referencias nulas, normalmente son predecibles: puntos y l�neas, se dibujan con un tama�o y anchura de 1 pixel y sin antialiasing, el color intr�nseco es blanco, la transparencia desactivada, y el buffer de profundidad est� activado y es accesible tanto para lectura como escritura.

Appearance()

Un componente Appearance normalmente referencia uno o m�s componentes atributo, llamando a los siguientes m�todos:

M�todos de Appearance (Excluyendo iluminaci�n y texturas)

Cada m�todo selecciona su objeto NodeComponent correspondiente para que sea parte del paquete de apariencia actual.

void setPointAttributes(PointAttributes pointAttributes)
void setLineAttributes(LineAttributes lineAttributes)
void setPolygonAttributes(PolygonAttributes polygonAttributes)
void setColoringAttributes(ColoringAttributes coloringAttributes)
void setTransparencyAttributes(TransparencyAttributes 
					transparencyAttributes)
void setRenderingAttributes(RenderingAttributes renderingAttributes)

.�Compartir Objetos NodeComponent

Es legal e incluso deseable que varios objetos referencien, y por lo tanto compartan, los mismos objetos NodeComponent. Por ejemplo, en la Figura 2-21. dos objetos Shape3D referencian al mismo componente Appearance. Tambi�n, dos objetos Appearance diferentes comparten el mismo componente LineAttributes.

Figura 2-21, Varios Objetos Appearance Comparten un NodeComponent

Compartir el mismo NodeComponent puede mejorar el rendimiento. Por ejemplo, si varios componentes Appearance comparten el mismo componente LineAttributes, lo que permite el antialias, el motor renderizador de Java 3D podr�a decidir agrupar el marco de trabajo antialias. Esto podr�a minimizar la activaci�n y desactivaci�n del antialias, lo que ser�a m�s r�pido.

Observa que es ilegal que un Nodo tenga m�s demun padre. Sin embargo, como los NodeComponents son referenciados, no son objetos Node, por lo que realmente no tienen padres. Por lo tanto, los objetos NodeComponent pueden ser compartidos (referenciados) por cualquier n�mero de otros objetos.

.�Clases Attribute

En esta secci�n se describen las seis primeras subclases de NodeComponent que pueden ser referenciadas por Appearance (excluyendo las de iluminaci�n y texturas).

PointAttributes

Los objetos PointAttributes manejan el modo en que se redibujan los puntos primitivos. Por defecto, si un v�rtice se renderiza como un punto, rellena un �nico pixel. Podemos usar setPointSize() para hacer un punto m�s grande. Sin embargo, por defecto, un punto mayor se parece a un cuadrado, a menos que usemos setPointAntialiasingEnable(). Los puntos Antialiasing cambian los colores de los pixels para hacer que el punto parezca "redondeado" (o al menos, un cuadrado menos visible).

Constructores de PointAttributes

PointAttributes()

Crea un objeto componente que describe puntos de un pixel sin antialiasing.

PointAttributes(float pointSize, boolean state)

Crea un objeto componente que describe el tama�o de pixel para los puntos y si permite o no el antialiasing.

M�todos de PointAttributes

void setPointSize(float pointSize)

Describe el tama�o de pixels para los puntos.

void setPointAntialiasingEnable(boolean state)

Activa o desactiva el antialising de los puntos. Visualmente interesante s�lo si el punto es mayor de un pixel.

LineAttributes

Los objetos LineAttributes cambian el modo en que se renderizan las l�neas primitivas de tres formas. Por defecto, una l�nea se dibuja s�lida rellena, de un pixel de ancho, y sin antialiasing. Podemos cambiar estos atributos llamando a los m�todos setLinePattern(), setLineWidth(), y setLineAntialiasingEnable().

Constructores de LineAttributes

LineAttributes()

Crea un objeto componente que describe l�neas rellenas de un pixel de ancho, s�lidas rellenas, sin antialiasing.

LineAttributes(float pointSize, int linePattern, boolean state)

Crea un objeto componente que describe el tama�o de pixel para l�neas, el patr�n de uso para dibujo y si se activa o no el antialiasing.

M�todos de LineAttributes

void setLineWidth(float lineWidth)

Describe la anchura de pixels para l�neas.

void setLinePattern(int linePattern)

donde linePattern es una de estas constantes: PATTERN_SOLID (por defecto), PATTERN_DASH, PATTERN_DOT, o PATTERN_DASH_DOT. Describe c�mo se deber�an rellenar los pixels de una l�nea.

void setLineAntialiasingEnable(boolean state)

Activa o desactiva el antialiasing.

PolygonAttributes

PolygonAttributes gobierna el modo en que se renderizan los pol�gonos primitivos de tres formas: c�mo es rasterizado, si est� recortado, y si se aplica un desplazamiento de profundidad especial. Por defecto, un pol�gono est� relleno, pero setPolygonMode() puede cambiar el modo en el que se dibuja el pol�gono como un marco (l�neas) o s�lo con los puntos de los v�rtices. (En las �ltimas dos clases, LineAttributes o PointAttributes tambi�n afectaban a como se visualiza el primitivo). Se podr�a usar el m�todo setCullFace() para reducir el n�mero de pol�gonos que son renderizados. Si setCullFace() se selecciona a CULL_FRONT o CULL_BACK, como media, no se renderizadan la mitad de los pol�gonos.

Por defecto, los v�rtices se renderizan como marcos y los pol�gonos rellenos no siempre se rasterizan con los mismos valores de profundidad, lo que podr�a hacer el estrechamiento cuando el marco fuera totalmente visible. Con setPolygonOffset(), los valores de profundidad de los pol�gonos rellenos se pueden mover hacia el plato de imagen, para que el marco enmarque el objeto relleno de la forma apropiada. setBackFaceNormalFlip() es ut�l para renderizar un pol�gono relleno, donde ambos lados del pol�gono van a ser sombreados.

Constructores de PolygonAttributes

PolygonAttributes()

Crea un objeto componente con pol�gonos rellenos por defecto, sin recortado y sin desplazamiento.

PolygonAttributes(int polygonMode, int cullFace, float polygonOffset)

Crea un objeto componente para renderizar pol�gonos como sus puntos, l�neas o pol�gonos rellenos, con el recorte de caras y el desplazamiento especificados.

PolygonAttributes(int polygonMode, int cullFace, 
                   float polygonOffset, boolean backFaceNormalFlip)

Crea un objeto componente similar al constructor anterior, pero tambien invierte c�mo ser�n determinados los pol�gonos trasero y frontal.

M�todos de PolygonAttributes

void setCullFace(int cullFace)

donde cullFace es uno de los siguientes: CULL_FRONT, CULL_BACK, o CULL_NONE. Oculta (no renderiza) los pol�gonos de la cara frontal o trasera, o no recorta los pol�gonos en absoluto.

void setPolygonMode(int polygonMode)

donde polygonMode es uno de estos: POLYGON_POINT, POLYGON_LINE, o POLYGON_FILL. Renderizan los pol�gonos seg�n sus puntos, sus l�neas o pol�gonos rellenos (por defecto).

void setPolygonOffset(float polygonOffset)

donde polygonOffset es el desplazamiento del espacio de pantalla a�adido para ajustar el valor de profundidad de los pol�gonos primitivos.

void setBackFaceNormalFlip(boolean backFaceNormalFlip)

donde backFaceNormalFlip determina si los v�rtices de los pol�gonos de las caras traseras deber�an ser negados antes de iluminarlos. Cuando est� bandera se selecciona a True y el recorte de la parte trasera est� desactivado, un pol�gono se renderiza como si tuviera dos lados con oposicci�n normal.

ColoringAttributes

ColoringAttributes controla c�mo se colorea cualquier primitivo. setColor() selecciona un color intr�nseco, que en algunas situaciones espec�fica el color del primitivo. Tambi�n setShadeModel() determina si el color es interpolado entre primitivos (normalmente pol�gonos y l�neas).

Constructores de ColoringAttributes

ColoringAttributes()

Crea un objeto componente usando blanco como el color intr�nseco y SHADE_GOURAUD como el modelo de sombreado por defecto.

ColoringAttributes(Color3f color, int shadeModel)
ColoringAttributes(float red, float green, float blue, int shadeModel)

donde shadeModel es uno de SHADE_GOURAUD, SHADE_FLAT, FASTEST, o NICEST. Ambos constructores crean un objeto componente usando los par�metros especificados para el color intr�nseco y el modelo de sombreado (en la mayor�a de los casos FASTEST es tambi�n SHADE_FLAT, y NICEST es tambi�n SHADE_GOURAUD.)

M�todos de ColoringAttributes

void setColor(Color3f color)
void setColor(float red, float green, float blue)

Ambos m�todos especifican el color intr�nseco.

void setShadeModel(int shadeModel)

donde shadeModel es uno de estos: SHADE_GOURAUD, SHADE_FLAT, FASTEST, o NICEST. Especifica el modelo de sombreado para renderizar primitivos.

Como los colores tambi�n se pueden definir para cada v�rtice de un objeto Geometry, podr�a haber un confilcto con el c�lor intr�nseco definido por ColoringAttributes. En el caso de dicho conflicto, los colores definidos en el objeto Geometry sobreescriben al color intr�nseco de ColoringAttributes. Si la iluminaci�n est� activada, tambi�n se ignora el color intr�nseco de ColoringAttributes.

TransparencyAttributes

TransparencyAttributes maneja la transparencia de cualquier primitivo. setTransparency() define el valor de opacidad para el primitivo. setTransparencyMode() activa la transparencia y selecciona el tipo de rasterizaci�n usado para producir la transparencia.

Constructores de TransparencyAttributes

TransparencyAttributes()

Crea un objeto componente con el modo de transparencia de FASTEST.

TransparencyAttributes(int tMode, float tVal)

donde tMode es uno de BLENDED, SCREEN_DOOR, FASTEST, NICEST, o NONE, y tVal especifica la opacidad del objeto (0.0 denota total opacidad y 1.0, total transparencia). Crea un objeto componente con el m�todo especificado para la renderizaci�n de transparencia y el valor de opacidad de la apariencia del objeto.

M�todos de TransparencyAttributes

void setTransparency(float tVal)

donde tVal especifca una opacidad de objeto donde (0.0 denota total opacidad y 1.0, total transparencia).

void setTransparencyMode(int tMode)

donde tMode (uno de BLENDED, SCREEN_DOOR, FASTEST, NICEST, o NONE) especifica c�mo se realiza la transparencia.

RenderingAttributes

RenderingAttributes controla dos operaciones diferentes de renderizado pixel-a-pixel: el buffer de profundidad y el texteo alpha setDepthBufferEnable() y setDepthBufferWriteEnable() determinan si se usa y c�mo se usa el buffer de profundidad para ocultar una superficie elininada. setAlphaTestValue() y setAlphaTestFunction() determinan si se usa y c�mo la funci�n alpha.

Constructores de RenderingAttributes

RenderingAttributes()

Crea un objeto componente que define estados de renderizado por-pixel con el buffer de profundidad activado y la funci�n alpha desactivada.

RenderingAttributes(boolean depthBufferEnable, 
		boolean depthBufferWriteEnable,
		float alphaTestValue, int alphaTestFunction)

donde depthBufferEnable activa y desactica las comparaciones del buffer de profundidad, depthBufferWriteEnable activa y desactiva la escritura en el buffer de profundidad, alphaTestValue se usa para comprobar contra una fuente de valores alpha entrantes, y alphaTestFunction es uno de ALWAYS, NEVER, EQUAL, NOT_EQUAL, LESS, LESS_OR_EQUAL, GREATER, o GREATER_OR_EQUAL, lo que denota el tipo de prueba alpha activa. Crea un objeto componente que define los estados de renderizado para comparaciones del buffer de produndidad y pruebas alpha.

M�todos de RenderingAttributes

void setDepthBufferEnable(boolean state)

activa y desactiva la prueba del buffer de profundidad.

void setDepthBufferWriteEnable(boolean state)

activa y desactiva la escritura en el buffer de seguridad.

void setAlphaTestValue(float value)

especifica el valor a usar en la prueba contra valores alpha entranres.

void setAlphaTestFunction(int function)

donde function es uno de: ALWAYS, NEVER, EQUAL, NOT_EQUAL, LESS, LESS_OR_EQUAL, GREATER, o GREATER_OR_EQUAL, que denota el tipo de prueba alpha a realizar. Si la funci�n es ALWAYS (por defecto), entonces la prueba alpha est� efectivamente desactivada.

Atributos de Apariencia por Defecto

El constructor de Appearance por defecto inicializa un objeto Appearance con todos los atributos seleccionados a null. La siguiente tabla lista los valores por defecto para dichos atributos con referencia null.

color white (1, 1, 1)
texture environment mode TEXENV_REPLACE
texture environment color white (1, 1, 1)
depth test enable true
shade model SHADE_GOURAUD
polygon mode POLYGON_FILL
transparency enable false
transparency mode FASTEST
cull face CULL_BACK
point size 1.0
line width 1.0
point antialiasing enable false
line antialiasing enable false

.�Ejemplo: Recortar la cara trasera

Los Pol�gonos tienen dos caras. Para muchos objetos visuales, s�lo se necesita renderizar una de las caras. Para reducir el poder de c�lculo necesario para renderizar las superficies pol�gonales, el renderizador puede recortar las caras innecesarias. El comportamiento de recortado se define mediante el PolygonAttribute del componente Appearance. La cara frontal de un objeto es la cara cuyos v�rtices est�n definidos en orden contrario a las agujas del reloj.

TwistStripApp.java crea un objeto visual (un tornado) que rota sobre su eje Y. Mientras el tornado rota, algunas partes parecen desaparecer. Las piezas desaparecidas se notan f�cilmente en el Figura 2-22.

Realmente, TwistStripApp define dos objetos visuales, con la misma geometr�a - que un tornado. Uno de los objetos visuales se renderiza como un marco, y el otro como una superficie s�lida. Como los dos objetos tienen la misma localizaci�n y orientaci�n, el objeto visual marco s�lo es visible cuando no se ve el objeto s�lido.

Figura 2-22, Un tornado con la cara trasera recortada.

La raz�n por la que desaparecen los pol�gonos es que se ha especificado el modelo de recortado, con su valor por defecto CULL_BACK. Los tir�ngulos de la superficie desaparecen cuando su lado trasero (cara trasera) da hacia el plato de imagen. Esta caracter�stica permite al sistema de renderizado ignorar las superficies triangulares que no son necesarias, se quiera o no.

Sin embargo, algunas veces el recorte de la cara trasera es un problema, como en el TwistStripApp. El problema tiene una soluci�n sencilla: desactivar el recortado. Para hacer esto, creamos un componente Appearance que referencie al componente PolygonAttributes que desactiva el recortado, como se ve en el fragmento de c�digo 2-10.

Framento de c�digo 2-10, Desactivar el recortado de la cara trasera para el tornado
1.     PolygonAttributes polyAppear = new PolygonAttributes();
2.     polyAppear.setCullFace(PolygonAttributes.CULL_NONE);
3.     Appearance twistAppear = new Appearance();
4.     twistAppear.setPolygonAttributes(polyAppear);
5.     // several lines later, after the twistStrip TriangleStripArray has
6.     // been defined, create a Shape3D object with culling turned off
7.     // in the Appearance bundle, and add the Shape3D to the scene graph
8.     twistBG.addChild(new Shape3D(twistStrip, twistAppear));

En la Figura 2-23, la desactivaci�n del recorte de las caras traseras realmente funciona. Ahora se renderizan todos los pol�gonos, no importa la direcci�n en la que se muestren.

Figura 2-23, Tornado sin recorte de las caras traseras

La cara frontal de un pol�gono es el lado en el que los v�rtices aparecen en orden contrario a las agujas del reloj. Est� normalmente es referida como la "Regla de la Mano Derecha". La regla usada para derterminar la cara frontal de un marco geom�trico (es dedir, tri�ngulo, cuadrado) alterna cada elemento del marco. La figura 2-24 muestra ejemplos del uso de la regla de la mano derecha para determinar las caras frontales.

Figura 2-24, Determinar la Cara Frontal de los Pol�gonos

COMPARTE ESTE ARTÍCULO

COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN LINKEDIN
COMPARTIR EN WHATSAPP
ARTÍCULO ANTERIOR

SIGUIENTE ARTÍCULO