Les extensions JavaTM

Les formes de bases
Les constructions géométriques
Les fonds d'écran
L'importation de scènes 3D

Suite à la présentation des notions utiles en Java 3D, ce chapitre décrit les différentes techniques de création des objets 3D par :

• l'assemblage de formes de base
• la description de formes géométriques
• l'application d'un effet 3D à un texte
• l'importation de scènes existantes.

Les formes de base

Les différentes formes

Les objets 3D affichés avec Java 3D sont manipulés soit sous forme de feuilles ajoutées à l'arbre d'une scène 3D, soit sous forme de groupes contenant des feuilles . Les feuilles sont des formes 3D de classe Shape3D. Cette classe décrit la construction géométrique de l'objet et ses différents attributs d'apparence.
Pour simplifier la construction de scènes 3D, le package com.sun.j3d.utils.geometry fournit les classes utilitaires suivantes :

• Les classes Box, Sphere, Cylinder et Cone représentant les objets de formes parallélépipède, sphère, cylindre et cône.
• La classe ColorCube représentant un cube avec 6 faces de couleur différente.
• La classe Text2D permettant d'afficher un texte sans épaisseur (le texte 3D est construit géométriquement avec la classe javax.media.j3d.Text3D).

L'assemblage de formes parallélépipédique, sphérique, cylindrique ou conique permet de construire beaucoup d'objets 3D aux formes complexes. Cet assemblage s'effectue en appliquant des homothéties, des rotations et des translations sur chaque objet simple.

Voici l'applet SimpleObjects dérivant de la classe Applet3D : cet exemple met en scène les quatre objets de forme simple et de classes Box, Sphere, Cylinder et Cone sur un fond d'écran blanc :

import javax.media.j3d.*;
import javax.vecmath.*;
import com.sun.j3d.utils.geometry.*;
import com.sun.j3d.utils.applet.MainFrame;
 
public class SimpleObjects extends Applet3D 
{
  // Méthode de la classe Applet3D outrepassée
  public BranchGroup createSceneTree ()
  {
    // Racine de l'arbre des objets représentés dans la scène 3D
    BranchGroup root = new BranchGroup ();
    
    // Instantiation des quatre classes de forme simple et
    // création de 4 transformations pour les placer dans l'espace
    // Création d'un parallélépipède
    Box box = new Box (0.3f, 0.2f, 0.2f, null);
    Transform3D boxTranslation = new Transform3D ();
    boxTranslation.setTranslation (new Vector3f (-0.4f, 0.4f, 0));
    TransformGroup boxTranslationGroup = new TransformGroup (boxTranslation);
    
    // Création d'une sphère
    Sphere sphere = new Sphere (0.3f);
    Transform3D sphereTranslation = new Transform3D ();
    sphereTranslation.setTranslation (new Vector3f (0.4f, 0.4f, 0));
    TransformGroup sphereTranslationGroup = new TransformGroup (sphereTranslation);
 
    // Création d'un cylindre
    Cylinder cylinder = new Cylinder (0.3f, 0.5f);
    Transform3D cylinderTransformation = new Transform3D ();
    cylinderTransformation.setTranslation (new Vector3f (-0.4f, -0.4f, 0));
    // Création d'une rotation pour mieux apercevoir la forme du cylindre
    Transform3D rotation = new Transform3D ();
    rotation.rotX (Math.PI / 6);
    // Multiplication des deux transformations pour les cumuler
    cylinderTransformation.mul (rotation);
    TransformGroup cylinderTransformationGroup = 
        new TransformGroup (cylinderTransformation);
 
    // Création d'un cone
    Cone cone = new Cone (0.3f, 0.5f);
    Transform3D coneTransformation = new Transform3D ();
    coneTransformation.setTranslation (new Vector3f (0.4f, -0.4f, 0));
    coneTransformation.mul (rotation);
    TransformGroup coneTransformationGroup = new TransformGroup (coneTransformation);
 
    // Création d'un fond blanc pour apercevoir les objets qui sont noirs par défaut
    Background background = new Background (1, 1, 1);
    background.setApplicationBounds (new BoundingBox ());
    
    // Construction de l'arbre de la scène 3D
    boxTranslationGroup.addChild (box);
    sphereTranslationGroup.addChild (sphere);
    cylinderTransformationGroup.addChild (cylinder);
    coneTransformationGroup.addChild (cone);
    root.addChild (boxTranslationGroup);
    root.addChild (sphereTranslationGroup);
    root.addChild (cylinderTransformationGroup);
    root.addChild (coneTransformationGroup);
    root.addChild (background);
    
    return root;
  }
 
  // Methode main () pour permettre d'utiliser cette classe 
  // comme applet ou comme application
  public static void main (String [] args) 
  {
    new MainFrame (new SimpleObjects (), args, 150, 150);
  }  
}

Figure 8. Arbre de la scène SimpleObjects

La figure précédente représente l'arbre de la scène créée par la méthode createSceneTree () de la classe SimpleObjects. Les instances des classes Box, Sphere, Cylinder et Cone ont été représentées sous forme de feuilles pour des commodités de représentation, mais ces objets sont en fait des groupes dont la classe hérite des classes com.sun.j3d.utils.geometry.Primitive et Group. Chacun de ces groupes a un certains nombre d'enfants de classe Shape3D représentant les différentes parties de la forme 3D. Le noeud représente le fond d'écran.

La classe Clown est aussi un exemple plus complexe d'assemblage de formes simples représentant un clown.

La classe javax.media.j3d.Shape3D

Cette classe dérive des classes SceneGraphObject, Node, Leaf et représente une feuille utilisée comme forme 3D dans l'arbre d'une scène 3D. A une forme 3D sont associés une construction géométrique et des attributs d'apparence appliqués à la forme 3D.
A partir de la version 1.2 de Java 3D, il est possible d'associer plusieurs constructions géométriques à une même forme 3D si elles sont équivalentes (il n'est pas possible de mélanger par exemple une description de texte 3D avec celle d'une forme géométrique).

Champs (constantes de capacité)

public static final int ALLOW_GEOMETRY_READ
public static final int ALLOW_GEOMETRY_WRITE 

Ces capacités permettent d'autoriser l'interrogation et la modification de la liste des constructions géométriques associées à cette forme 3D.

public static final int ALLOW_APPEARANCE_READ
public static final int ALLOW_APPEARANCE_WRITE

Ces capacités permettent d'autoriser l'interrogation et la modification des attributs d'apparence utilisés par cette forme 3D.

public static final int ALLOW_COLLISION_BOUNDS_READ
public static final int ALLOW_COLLISION_BOUNDS_WRITE 

Ces capacités permettent d'autoriser l'interrogation et la modification des limites utilisées pour la collision de cette forme 3D.

public static final int ALLOW_APPEARANCE_OVERRIDE_READ
public static final int ALLOW_APPEARANCE_OVERRIDE_WRITE

Constructeurs

public Shape3D ()
public Shape3D (Geometry geometry)
public Shape3D (Geometry geometry, Appearance appearance)

Principales méthodes

public Geometry getGeometry ()	(capacité ALLOW_GEOMETRY_READ)
public void setGeometry (Geometry geometry)	(capacité ALLOW_GEOMETRY_WRITE)

Ces méthodes permettent d'interroger ou de modifier la construction géométrique geometry de cette forme 3D. A partir de la version 1.2 de Java 3D, ces méthodes permettent de manipuler la construction géométrique d'indice 0.

public Geometry getGeometry (int index)	(capacité ALLOW_GEOMETRY_READ)
public java.util.Enumeration getAllGeometries ()	(capacité ALLOW_GEOMETRY_READ)
public int numGeometries ()	(capacité ALLOW_GEOMETRY_READ)

Ces méthodes permettent d'interroger sur cette forme 3D la construction géométrique d'indice index, la liste de toutes les constructions géométriques sous forme d'énumération ou son nombre (compatible à partir de la version 1.2 de Java 3D).

public void addGeometry (Geometry geometry)	(capacité ALLOW_GEOMETRY_WRITE)
public void insertGeometry (Geometry geometry, int index)	(capacité ALLOW_GEOMETRY_WRITE)
public void setGeometry (Geometry geometry, int index)	(capacité ALLOW_GEOMETRY_WRITE)

Ces méthodes permettent d'ajouter, d'insérer ou de modifier la construction géométrique geometry à l'indice index de cette forme 3D (compatible à partir de la version 1.2 de Java 3D).

public void removeGeometry (int index)  (capacité ALLOW_GEOMETRY_WRITE)

Retire la construction géométrique de cette forme 3D (compatible à partir de la version 1.2 de Java 3D).

public Appearance getAppearance ()	(capacité ALLOW_APPEARANCE_READ)
public void setAppearance (Appearance appearance)	(capacité ALLOW_APPEARANCE_WRITE)

Ces méthodes permettent d'interroger ou de modifier les attributs d'apparence utilisées par cette forme 3D.

public Bounds getCollisionBounds ()	(capacité ALLOW_COLLISION_BOUNDS_READ)
public void setCollisionBounds (Bounds bounds)	(capacité ALLOW_COLLISION_BOUNDS_WRITE)

Ces méthodes permettent d'interroger ou de modifier les limites utilisées pour la collision de cette forme 3D.

Exemples

Applets Pyramid, HelloWorld3D, LitApplet3D, TextTranslation, SunEarthMoonMotion.
Classe AxisShape.

La classe com.sun.j3d.utils.geometry.ColorCube

Cette classe dérive des classes SceneGraphObject, Node, Leaf, Shape3D et représente un cube centré sur l'origine du repère dont les 6 faces sont de couleur différente. Elle est surtout utile pour des fins de démonstration.

Constructeurs

public ColorCube ()
public ColorCube (double scale)

Ces constructeurs permettent de créer un cube dont les deux coins opposés ont pour coordonnées (-scale, -scale, -scale) et (scale, scale, scale). Par défaut, scale est égal à 1.

Exemples

Applets Applet3D, CubeSides, MultiCubes, AlphaTest.

La classe com.sun.j3d.utils.geometry.Primitive

Cette classe abtract dérive des classes SceneGraphObject, Node, Group et est utilisée comme super classe des classes Box, Sphere, Cylinder et Cone du package com.sun.j3d.utils.geometry. En tant que groupe, elle représente un conteneur de plusieurs formes 3D qui constituent un objet 3D et regroupe un ensemble de paramètres applicables à chacune de ces formes.
Par exemple, elle comporte une méthode setAppearance (Appearance appearance) qui permet de modifier les attributs d'apparence de toutes les formes 3D qu'elle regroupe.

Principaux champs

public static final int GENERATE_NORMALS
public static final int GENERATE_TEXTURE_COORDS
public static final int GEOMETRY_NOT_SHARED

Ces constantes sont passées en paramètre aux constructeurs des classes dérivées pour que le générateur de construction géométrique calcule les normales (utiles pour l'éclairage) ou les coordonnées utilisées pour appliquer les textures. GEOMETRY_NOT_SHARED indique qu'une construction géométrique séparée doit être créée pour les formes 3D de cette instance.

public static final int ENABLE_APPEARANCE_MODIFY

Cette constante est passée en paramètre aux constructeurs des classes dérivées pour activer les capacités ALLOW_APPEARANCE_READ and ALLOW_APPEARANCE_WRITE sur les instances de la classe Shape3D créées.

public static final int ENABLE_GEOMETRY_PICKING

Cette constante est passée en paramètre aux constructeurs des classes dérivées pour activer la capacité ALLOW_INTERSECT sur les constructions géométriques créées.

Principales méthodes

public abstract Shape3D getShape (int partid)

Renvoie la forme 3D générée à l'indice partid. Les classes dérivées de la classe Primitive définisse un ensemble de constantes égales aux indices des différentes formes 3D composant un objet.

public void setAppearance ()	(capacité ENABLE_APPEARANCE_MODIFY)
public abstract void setAppearance (Appearance appearance)	(capacité ENABLE_APPEARANCE_MODIFY)

Ces méthodes permettent de modifier les attributs d'apparence de toutes les formes 3D dont le parent est ce groupe. La méthode sans paramètre leur applique des attributs de classe Material utilisant une couleur noire sans éclairage et blanche sous éclairage.

public void setAppearance (int partid, Appearance appearance)

(capacité ENABLE_APPEARANCE_MODIFY)

Modifie les attributs d'apparence utilisés par la forme 3D à l'indice partid.

public Appearance getAppearance ()

(capacité ENABLE_APPEARANCE_MODIFY)

Renvoie les attributs d'apparence utilisés par la forme 3D à l'indice 0.

La classe com.sun.j3d.utils.geometry.Box

Cette classe dérive des classes SceneGraphObject, Node, Group, Primitive et représente un parallélépipède centré sur l'origine du repère. Elle implémente les méthodes getShape (int partid) et setAppearance (Appearance appearance) de la classe Primitive.

Champs

public static final int FRONT
public static final int BACK
public static final int RIGHT
public static final int LEFT
public static final int TOP
public static final int BOTTOM

Ces constantes désignent les différentes faces du parallélépipède (respectivement devant, derrière, droite, gauche, haut et bas). La classe Box utilise une forme 3D pour chaque face et ces constantes sont utilisées en paramètre de la méthode getShape () pour interroger chaque instance de Shape3D.

Constructeurs

public Box ()
public Box (float xdim, float ydim, float zdim, Appearance appearance)
public Box (float xdim, float ydim, float zdim, int primflags, Appearance appearance)

Ces constructeurs permettent de créer un parallélépipède dont les deux coins opposés ont pour coordonnées (-xdim, -ydim, -zdim) et (xdim, ydim, zdim). primflags peut être égal à une des constantes décrites dans la classe Primitive ou à une combinaison de ces constantes.
Par défaut, xdim, ydim, zdim sont égaux à 1, primflags à GENERATE_NORMALS et appearance à null ce qui crée un parallélépipède de couleur blanche uniquement sous éclairage.

Exemples

Applet SimpleObjects, SimpleTexturedObjects, Clock3D.

La classe com.sun.j3d.utils.geometry.Sphere

Cette classe dérive des classes SceneGraphObject, Node, Group, Primitive et représente une sphère centrée sur l'origine du repère. Elle implémente les méthodes getShape (int partid) et setAppearance (Appearance appearance) de la classe Primitive.

Champs

public static final int BODY

Cette constante est utilisée en paramètre de la méthode getShape () pour interroger l'instance de Shape3D représentant la sphère.

Constructeurs

public Sphere ()
public Sphere (float radius, Appearance appearance)
public Sphere (float radius, int primflags, Appearance appearance)
public Sphere (float radius, int primflags, int divisions)
public Sphere (float radius, int primflags, int divisions, Appearance appearance)

Ces constructeurs permettent de créer une sphère de rayon radius. La construction géométrique de la sphère est un assemblage de quadrilatères et divisions représente le nombre divisions utilisées sur chaque axe pour décomposer la sphère en facettes. primflags peut être égal à une des constantes décrites dans la classe Primitive ou à une combinaison de ces constantes.
Par défaut, radius est égal à 1, divisions à 15, primflags à GENERATE_NORMALS et appearance à null ce qui crée une sphère de couleur blanche uniquement sous éclairage.

Exemples

Applets SimpleObjects, Clown, SphereConstruction, SimpleTexturedObjects, LightEffect, SunEarthMoonMotion.

La classe com.sun.j3d.utils.geometry.Cylinder

Cette classe dérive des classes SceneGraphObject, Node, Group, Primitive et représente un cylindre centré sur l'origine du repère, dont l'axe central est confondu avec l'axe y. Elle implémente les méthodes getShape (int partid) et setAppearance (Appearance appearance) de la classe Primitive.

Champs

public static final int BODY
public static final int BOTTOM
public static final int TOP

Ces constantes désignent les 3 parties du cylindre (respectivement la partie cylindrique, et les disques bas et haut). Ces constantes sont utilisées en paramètre de la méthode getShape () pour interroger chaque instance de Shape3D du cylindre.

Constructeurs

public Cylinder ()
public Cylinder (float radius, float height)
public Cylinder (float radius, float height, Appearance appearance)
public Cylinder (float radius, float height, int primflags, Appearance appearance)
public Cylinder (float radius, float height, int primflags, 
                  int xdivision, int ydivision, Appearance appearance)

Ces constructeurs permettent de créer un cylindre de rayon radius et de hauteur height. La construction géométrique du cylindre est un assemblage de quadrilatères ; xdivision et ydivision représentent le nombre divisions utilisées sur l'axe x et sur la hauteur pour décomposer le cylindre en facettes. primflags peut être égal à une des constantes décrites dans la classe Primitive ou à une combinaison de ces constantes.
Par défaut, radius est égal à 1 , height à 2, xdivision à 15, ydivision à 1, primflags à GENERATE_NORMALS et appearance à null ce qui crée un cylindre de couleur blanche uniquement sous éclairage.

Exemples

Applets SimpleObjects, Clown, WaterGlass, SimpleTexturedObjects, Clock3D.

La classe com.sun.j3d.utils.geometry.Cone

Cette classe dérive des classes SceneGraphObject, Node, Group, Primitive et représente un cône centré sur l'origine du repère, dont l'axe central est confondu avec l'axe y. L'origine du repère est à mi hauteur de la hauteur du cône. La classe Cone implémente les méthodes getShape (int partid) et setAppearance (Appearance appearance) de la classe Primitive.

Champs

public static final int BODY
public static final int CAP

Ces constantes désignent les 2 parties du cône (respectivement la partie conique et le disque inférieur). Ces constantes sont utilisées en paramètre de la méthode getShape () pour interroger chaque instance de Shape3D du cône.

Constructeurs

public Cone ()
public Cone (float radius, float height)
public Cone (float radius, float height, int primflags, Appearance appearance)
public Cone (float radius, float height, int primflags, 
             int xdivision, int ydivision, Appearance appearance)

Ces constructeurs permettent de créer un cône de rayon radius et de hauteur height. La construction géométrique du cône est un assemblage de quadrilatères ; xdivision et ydivision représentent le nombre divisions utilisées sur l'axe x et sur la hauteur pour décomposer la surface du cône en facettes. primflags peut être égal à une des constantes décrites dans la classe Primitive ou à une combinaison de ces constantes.
Par défaut, radius est égal à 1 , height à 2, xdivision à 15, ydivision à 1, primflags à GENERATE_NORMALS et appearance à null ce qui crée un cône de couleur blanche uniquement sous éclairage.

Exemples

Applets SimpleObjects, Clown, SimpleTexturedObjects.

 

Les constructions géométriques

Les différents types de constructions géométriques

Une forme 3D peut avoir une des constructions géométriques suivantes :

• Un ensemble de points isolés. Les classes PointArray et IndexedPointArray sont utilisées pour stocker ces points.
• Un ensemble de lignes ou d'arêtes. Les classes LineArray, LineStripArray, IndexedLineArray et IndexedLineStripArray sont utilisées pour stocker les extrémités de ces lignes.
• Une surface plus ou moins complexe constituée par l'assemblage de facettes triangulaires ou de quadrilatères. Les classes dérivées de GeometryArray différentes de celles citées précédemment sont utilisées pour stocker les sommets (vertex/vertices en anglais) de ces facettes.
• Un texte avec une profondeur lui donnant un effet 3D (classe Text3D).
• Une image (raster) située à un point de l'espace (classe Raster).

Les classes qui utilisent ces types de construction géométrique héritent toutes de la classe Geometry :

• java.lang.Object
  • javax.media.j3d.SceneGraphObject
    • javax.media.j3d.NodeComponent
      • javax.media.j3d.Geometry
        • javax.media.j3d.CompressedGeometry
        • javax.media.j3d.GeometryArray
          • javax.media.j3d.PointArray
          • javax.media.j3d.LineArray
          • javax.media.j3d.TriangleArray
            
          • javax.media.j3d.QuadArray 
          • javax.media.j3d.GeometryStripArray
            • javax.media.j3d.LineStripArray
            • javax.media.j3d.TriangleStripArray
            • javax.media.j3d.TriangleFanArray
              
• javax.media.j3d.IndexedGeometryArray
• javax.media.j3d.IndexedPointArray
• javax.media.j3d.IndexedLineArray
• javax.media.j3d.IndexedTriangleArray
  
• javax.media.j3d.IndexedQuadArray 
• javax.media.j3d.IndexedGeometryStripArray
  • javax.media.j3d.IndexedLineStripArray
  • javax.media.j3d.IndexedTriangleStripArray
  • javax.media.j3d.IndexedTriangleFanArray
• javax.media.j3d.Raster
• javax.media.j3d.Text3D

Chacune des classes CompressedGeometry, GeometryArray, Raster et Text3D n'est pas équivalente à l'autre dans le sens où il n'est pas possible de définir une forme 3D avec la classe Shape3D en mélangeant les classes GeometryArray et Text3D par exemple. Dans ce cas, il faut créer deux instances de Shape3D différentes.
Une même instance de construction géométrique peut être éventuellement partagée par différentes formes 3D.

Les différents algorithmes de construction

Les classes qui dérivent de la classe GeometryArray vous donnent un large choix d'algorithmes pour décrire comment sont construites les facettes d'une surface à partir de la liste de ses sommets :

Figure 9. Algorithmes de construction géométrique des classes GeometryArray

CLASSES		DESCRIPTION DE L'ALGORITHME UTILISÉ
PointArray		Décrit un ensemble de points isolés à afficher à partir du tableau des sommets s.
LineArray		Décrit un ensemble de lignes, construites en reliant deux par deux chacun des sommets du tableau s.
TriangleArray		Décrit un ensemble de triangles formant les facettes d'une surface. Les triangles sont construits en utilisant trois par trois les sommets du tableau s.
QuadArray		Décrit un ensemble de quadrilatères formant les facettes d'une surface. Les quadrilatères sont construits en utilisant quatre par quatre les sommets du tableau s. Les sommets de chaque quadrilatère doivent être coplanaires (appartenir au même plan).
GeometryStripArray		Les classes LineStripArray, TriangleStripArray et TriangleFanArray qui dérivent de cette classe permettent d'optimiser la réutilisation des points du tableau s qui sont en commun dans une bande (strip).
	LineStripArray	Décrit un ensemble de lignes, construites en reliant chacun des sommets du tableau s les uns après les autres.
	TriangleStripArray	Décrit un ensemble de triangles formant les facettes d'une bande. Les triangles sont construits en respectant le schéma indiqué par la figure 9.
	TriangleFanArray	Décrit un ensemble de triangles formant les facettes d'un éventail (fan). Les triangles sont construits en reliant le premier sommet à tous les autres sommets du tableau s.

Les classes de formes de base suffisent dans la plupart des cas mais l'utilisation des classes ci-dessus permettent d'imaginer n'importe quelle surface et d'optimiser sa représentation.
Vous pouvez aussi utiliser la classe com.sun.j3d.utils.geometry.GeometryInfo qui simplifie la programmation des constructions géométriques. Le constructeur de cette classe prend en paramètre une constante désignant l'algorithme de construction des facettes à utiliser avec la liste des sommets. Ces algorithmes correspondent aux classes dérivant de la classe GeometryArray comme suit :

PARAMÈTRE GeometryInfo	CLASSE ÉQUIVALENTE
TRIANGLE_ARRAY	TriangleArray
QUAD_ARRAY	QuadArray
TRIANGLE_FAN_ARRAY	TriangleStripArray
TRIANGLE_STRIP_ARRAY	TriangleFanArray
POLYGON_ARRAY	Pas d'équivalent. Permet de décrire un polygone ayant éventuellement des trous.

Constructions géométriques indicées

javax.media.j3d.Geometry javax.media.j3d.GeometryArray   javax.media.j3d.PointArray javax.media.j3d.LineArray javax.media.j3d.TriangleArray javax.media.j3d.QuadArray  javax.media.j3d.GeometryStripArray javax.media.j3d.LineStripArray javax.media.j3d.TriangleStripArray javax.media.j3d.TriangleFanArray

javax.media.j3d.Geometry javax.media.j3d.GeometryArray javax.media.j3d.IndexedGeometryArray javax.media.j3d.IndexedPointArray javax.media.j3d.IndexedLineArray javax.media.j3d.IndexedTriangleArray javax.media.j3d.IndexedQuadArray  javax.media.j3d.IndexedGeometryStripArray javax.media.j3d.IndexedLineStripArray javax.media.j3d.IndexedTriangleStripArray javax.media.j3d.IndexedTriangleFanArray

Toutes les classes qui héritent de la classe IndexedGeometryArray ont le même nom préfixé par Indexed que les classes qui dérivent directement de la classe GeometryArray (par exemple IndexedQuadArray pour QuadArray). Ces classes utilisent leur liste de sommets en respectant le même algorithme que leur classes "soeur" mais l'ensemble des sommets est un tableau d'indices au lieu d'être un tableau de coordonnées, comme le montre la figure ci-dessous.

Figure 10. Comparaison des constructions géométriques non indicées/indicées

Cette figure montre deux manières de construire les 4 faces d'une pyramide, l'une avec la classe TriangleFanArray l'autre avec la classe IndexedTriangleFanArray. La pyramide peut être décomposée en deux éventails, l'un avec trois triangles centré en s0 et l'autre avec un seul triangle centré en s1.
L'instance de la classe TriangleFanArray n'a besoin que d'un seul tableau avec les coordonnées des 8 sommets pour décrire les faces. L'instance de la classe IndexedTriangleFanArray a besoin de deux tableaux :

• Le tableau contenant les coordonnées des 4 sommets de la pyramide.
• Le tableau décrivant les faces en utilisant les indices renvoyant à un sommet du premier tableau.

L'usage des constructions géométriques indicées est souvent plus complexe à programmer mais permet d'économiser en mémoire et sur certains calculs des sommets pour Java 3D. Dans le cas de la pyramide, la moitié de ces calculs est économisée car les calculs sur s1, s2 et s3 ne seront exécutés qu'une seule fois avec la classe IndexedTriangleFanArray.
Cette complexité est simplifiée grâce à la classe com.sun.j3d.utils.geometry.GeometryInfo qui calcule automatiquement une instance de IndexedGeometryArray à partir d'une construction géométrique non indicée.

Voici l'applet Pyramid dérivant de la classe Applet3D : cet exemple construit une pyramide colorée. Une couleur différente a été donnée à chaque sommet, ce qui donne par défaut cet effet de dégradé obtenu par interpolation des couleurs.

import javax.media.j3d.*;
import javax.vecmath.*;
import com.sun.j3d.utils.geometry.*;
import com.sun.j3d.utils.applet.MainFrame;
 
public class Pyramid extends Applet3D
{
  public BranchGroup createSceneTree ()
  {
    // Racine de l'arbre des objets représentés dans la scène 3D
    BranchGroup root = new BranchGroup ();
    
    // Construction de la  branche de l'arbre de la scène
    root.addChild (createPyramid ());
    
    return root;
  }
 
  public Shape3D createPyramid ()
  {
    // Création des sommets et de leur couleur
    Point3f s0 = new Point3f (0, 0.5f, 0);
    Point3f s1 = new Point3f (0, -0.5f, 0.7f);
    Point3f s2 = new Point3f (0.7f, -0.5f, -0.3f);
    Point3f s3 = new Point3f (-0.7f, -0.5f, -0.3f);
    Color3f s0Color = new Color3f (1, 0, 0); // Rouge
    Color3f s1Color = new Color3f (0, 1, 0); // Vert
    Color3f s2Color = new Color3f (0, 0, 1); // Bleu
    Color3f s3Color = new Color3f (1, 1, 0); // Jaune
    
    // Construction de 2 éventails avec les points et leur couleur
    GeometryInfo geometryInfo = new GeometryInfo (GeometryInfo.TRIANGLE_FAN_ARRAY);    
    geometryInfo.setCoordinates (new Point3f [ ] {s0, s1, s2, s3, s1,
                                                  s2, s1, s3});
    geometryInfo.setColors (new Color3f [ ] {s0Color, s1Color, s2Color, s3Color, s1Color, 
                                              s2Color, s1Color, s3Color});
    geometryInfo.setStripCounts (new int [ ] {5, 3});
    
    // Forme créée avec cette construction géométrique
    return new Shape3D (geometryInfo.getIndexedGeometryArray ());
  }
 
  // Méthode main () pour permettre d'utiliser cette classe 
  // comme applet ou comme application
  public static void main (String [] args) 
  {
    new MainFrame (new Pyramid (), args, 100, 100);
  }  
}

L'ordre dans lequel sont cités les sommets des facettes est important. Pour qu'une facette extérieure soit visible, ses sommets doivent respecter le sens direct, c'est à dire qu'ils doivent être énumérés dans le sens inverse des aiguilles d'une montre quand la facette est face à vous.

La classe javax.media.j3d.NodeComponent

Cette classe abstract dérive de la classe SceneGraphObject. C'est la super classe des classes Geometry et Appearance et de toutes les classes d'attributs. Elle définit quelques méthodes utilisées pour la duplication des classes dérivées.
Contrairement aux instances de la classe Node, les objets de classes NodeComponent peuvent être référencés plusieurs fois : une même instance de construction géométrique peut être utilisée par plusieurs formes 3D différentes.

La classe javax.media.j3d.Geometry

Cette classe abstract dérive des classes SceneGraphObject et NodeComponent. C'est la super classe de toutes les classes de constructions géométriques GeometryArray, Text3D, Raster, CompressedGeometry. Les instances de ces classes sont passées en paramètre aux méthodes addGeometry (), insertGeometry () et setGeometry () de la classe Shape3D.

Champ (constante de capacité)

public static final int ALLOW_INTERSECT 

Cette capacité permet d'utiliser cette construction géométrique dans les calculs d'intersection.

La classe javax.media.j3d.GeometryArray

Cette classe abstract dérive des classes SceneGraphObject, NodeComponent, Geometry. Toutes les classes qui en héritent permettent de créer une construction géométrique sous forme d'un ensemble de points, de lignes, de facettes triangulaires ou de quadrilatères.
Cette classe peut stocker au plus quatre types de données différentes :

• Les coordonnées des sommets de la construction géométrique.
• Les couleurs de ces sommets. La couleur d'une forme 3D peut être aussi changée en utilisant les attributs d'apparence.
• Les normales de ces sommets. Les normales sont utiles pour calculer les effets d'éclairage.
• Les coordonnées de texture.

Toutes les valeurs (coordonnées, couleurs,...) passées en paramètre à une instance de GeometryArray sont recopiées dans des structures internes.

Les classes GeometryInfo et NormalGenerator du package com.sun.j3d.utils.geometry sont développées ici plutôt que les nombreuses méthodes de la classe GeometryArray et de ses sous-classes, car ces deux classes permettent plus simplement de générer des constructions géométriques optimisées de classe GeometryArray.

Principaux champs (constantes de capacité)

public static final int ALLOW_COORDINATE_READ
public static final int ALLOW_COORDINATE_WRITE
public static final int ALLOW_COLOR_READ
public static final int ALLOW_COLOR_WRITE
public static final int ALLOW_NORMAL_READ
public static final int ALLOW_NORMAL_WRITE
public static final int ALLOW_TEXCOORD_READ
public static final int ALLOW_TEXCOORD_WRITE

Ces capacités permettent d'autoriser la lecture ou la modification des coordonnées des sommets, de leur couleur, de leur normale ou leurs coordonnées de texture.

La classe com.sun.j3d.utils.geometry.GeometryInfo

Cette classe utilitaire permet de générer des constructions géométriques de classe GeometryArray. Comme pour cette classe, elle peut stocker les coordonnées des sommets, leur couleur, leur normale et leurs coordonnées de texture. Accompagnée des classes NormalGenerator, Triangulator, Stripifier, elle évite la programmation des tâches suivantes au moment de la création de constructions géométriques :

• Le calcul des normales.
• L'optimisation par utilisation des classes de bandes (strip).
• L'optimisation par utilisation de constructions géométriques indicées.
• La décomposition de formes polygonales en facettes triangulaires.

Une fois renseignées les coordonnées des sommets et éventuellement les autres paramètres d'une construction géométrique, une instance de classe GeometryArray configurée avec toutes les données peut être générée grâce aux méthodes getGeometryArray () et getIndexedGeometryArray ().

Champs

public static final int TRIANGLE_ARRAY
public static final int QUAD_ARRAY 
public static final int TRIANGLE_FAN_ARRAY 
public static final int TRIANGLE_STRIP_ARRAY
public static final int POLYGON_ARRAY

Ces constantes sont passées en paramètre au constructeur de la classe GeometryInfo pour spécifier quel algorithme de construction géométrique est utilisé pour le tableau des sommets.
La constante POLYGON_ARRAY indique que les sommets représentent le contour d'une surface polygonale. Il n'est pas obligatoire que cette surface soit plane et la méthode setContourCounts () permet d'indiquer si cette surface comporte des trous. La surface polygonale est automatiquement décomposée en facettes triangulaires.

Constructeur

public GeometryInfo (int primitive)

Crée une instance de la classe GeometryInfo. primitive peut être égal à TRIANGLE_ARRAY, QUAD_ARRAY, TRIANGLE_FAN_ARRAY, TRIANGLE_STRIP_ARRAY, POLYGON_ARRAY pour indiquer quel algorithme utilisé.

Principales méthodes

public void setCoordinates (Point3f [] coordinates)
public void setCoordinates (float [] coordinates)

Ces méthodes permettent de modifier la liste des sommets des facettes. Les valeurs passées en paramètre sont recopiées.

public void setStripCounts (int [] coordinateIndices)

Si l'instance de GeometryInfo est créée avec TRIANGLE_FAN_ARRAY ou TRIANGLE_STRIP_ARRAY comme algorithme, le tableau coordinateIndices indique le nombre de sommets utilisés pour construire chaque bande à partir du tableau des sommets. coordinateIndices.length est égal au nombre de bandes. Si les sommets décrivent une seule bande l'appel à cette méthode n'est pas obligatoire.
Dans l'exemple de la pyramide, coordinateIndices est initialisé à {5, 3}.

public void setContourCounts (int [] contourCounts)

Si l'instance de GeometryInfo a été créée avec POLYGON_ARRAY comme algorithme, le tableau contourCounts indique le nombre de sommets utilisés pour construire le contour du polygone puis les trous à partir du tableau des sommets. coordinateIndices.length est égal au nombre de trous + 1. Si le polygone n'a pas de trou, l'appel à cette méthode n'est pas obligatoire.

public void setColors (Color3f [] colors)
public void setColors (Color4f [] colors)

Ces méthodes permettent de modifier la couleur des sommets. Les attributs d'apparence positionnés sur la forme 3D permettent d'interpréter cette information de couleur de différentes façons et de positionner une couleur directement sur une forme 3D. Par défaut, les facettes sont colorées par interpolation entre les différentes couleurs de ses sommets.

public void setNormals (Vector3f [] normals)
public void setNormals (float [] normals)

Ces méthodes permettent de modifier les normales des sommets. Vous pouvez aussi utiliser la classe NormalGenerator pour éviter de programmer leur calcul. Toutes les normales doivent avoir une longueur (norme) égale à 1.

public void setTextureCoordinates (Point2f [] texCoords)
public void setTextureCoordinates2 (float [] texCoords)
public void setTextureCoordinates (Point3f [] texCoords)
public void setTextureCoordinates3 (float [] texCoords)

Ces méthodes permettent de modifier les coordonnées de texture 2D ou 3D de chaque sommet.

public GeometryArray getGeometryArray ()
public IndexedGeometryArray getIndexedGeometryArray ()

Ces méthodes renvoient une instance des classes GeometryArray ou IndexedGeometryArray à passer en paramètre aux méthodes addGeometry (), insertGeometry () et setGeometry () de la classe Shape3D.
Si l'instance de GeometryInfo a été créée avec POLYGON_ARRAY comme algorithme, la surface décrite par les sommets sera d'abord transformée en facettes triangulaires.

Exemples

Applets Pyramid, LitPlane.
Classe AxisShape.

La classe com.sun.j3d.utils.geometry.NormalGenerator

Cette classe utilitaire permet de calculer les normales aux sommets d'une construction géométrique de classe GeometryInfo. Pour rappel, la normale à un sommet est le vecteur dont la direction est orthogonale au plan auquel appartient ce sommet. Les normales sont utiles en 3D pour calculer les effets d'éclairage.
La méthode generateNormals () utilise un angle de pli (crease) pour générer les normales. Soit alpha l'angle entre les normales des sommets en commun de deux facettes adjacentes : si alpha < creaseAngle, une normale moyenne sera utilisée plutôt que les deux normales géométriques, ce qui donne un effet visuel adoucissant l'angle. Utilisez creaseAngle égal à 0 pour obtenir un effet de pli entre toutes les facettes.

Figure 11. Angle de pli

Constructeurs

public NormalGenerator ()
public NormalGenerator (double creaseAngle)

Ces constructeurs créent une instance de la classe NormalGenerator. creaseAngle est l'angle de pli en radian compris entre 0 et PI (par défaut égal à 44° en radian).

Principale méthode

public void generateNormals (GeometryInfo geometry)

Génère les normales des sommets de geometry.

Exemples

Classes AxisShape, LitPlane.

Construction d'une surface autour d'un axe central

Voici un exemple de classe réalisant une construction géométrique, à partir d'un profil projeté autour d'un axe central. Ceci correspond aux objets fabriquées sur un tour de potier.
La classe AxisShape calcule les facettes de ce type de surface en utilisant un tableau points de points 2D comme profil. L'axe y est l'axe de symétrie centrale. Le profil est appliqué tous les 2*PI/divisions radians sur tout un tour pour obtenir les sommets des facettes la forme 3D. L'algorithme de construction géométrique des quadrilatères est utilisé ici mais il est aussi possible d'utiliser d'autres algorithmes comme celui en bande de la classe TriangleStripArray.
Les classes GeometryInfo et NormalGenerator sont finalement utilisées pour simplifier le calcul des normales et obtenir une instance de IndexedGeometryArray sans peine.

Figure 12. Forme 3D construite autour d'un axe central

import javax.media.j3d.*;
import javax.vecmath.*;
import com.sun.j3d.utils.geometry.*;

public class AxisShape extends Shape3D
{
  private Point2f [] points;
  private int        divisions;

  public AxisShape (Point2f [] points, int divisions)
  {    
    this.points    = points;
    this.divisions = divisions;

    if (   points [0].x != 0 
        || points [points.length - 1].x != 0)
      throw new IllegalArgumentException ("First and last point x must be 0");

    // Construction du contour avec des quadrilatères 
    // utilisant le nombre de divisions en paramètre
    Point3f [] coords = new Point3f [(points.length - 1) * divisions * 4];    
    for (int i = 0, k = 0; i < divisions; i++)
      for (int j = 0; j < points.length - 1; j++)
      {
        double angle = 2 * Math.PI * i / divisions;
        float  cos = (float)Math.cos (angle);
        float  sin = (float)Math.sin (angle);

        // Calcul des 4 points de la facette
        Point3f point1 = new Point3f (points [j].x * cos, 
                                      points [j].y, 
                                      points [j].x * sin);
        Point3f point4 = new Point3f (points [j + 1].x * cos, 
                                      points [j + 1].y, 
                                      points [j + 1].x * sin);

        angle = 2 * Math.PI * (i + 1) / divisions;
        cos = (float)Math.cos (angle);
        sin = (float)Math.sin (angle);

        Point3f point2 = new Point3f (points [j].x * cos, 
                                      points [j].y, 
                                      points [j].x * sin);
        Point3f point3 = new Point3f (points [j + 1].x * cos, 
                                      points [j + 1].y, 
                                      points [j + 1].x * sin);
        // Contruction de la facette
        coords  [k++] = point1;
        coords  [k++] = point2;
        coords  [k++] = point3;
        coords  [k++] = point4;
      }

    // Utilisation de la classe utilitaire de construction géométrique
    GeometryInfo geometryInfo = new GeometryInfo (GeometryInfo.QUAD_ARRAY);
    geometryInfo.setCoordinates (coords);
    // Génération des normales
    new NormalGenerator ().generateNormals (geometryInfo);
    // Recopie dans la construction géométrique de cette forme
    setGeometry (geometryInfo.getIndexedGeometryArray ());
  }

  // Implémentation de la copie
  public Node cloneNode (boolean forceDuplicate) 
  {
    AxisShape node = new AxisShape (points, divisions);
    node.duplicateNode (this, forceDuplicate);
    return node;
  }
}

Voici l'applet AxisShapeDemo dérivant de la classe Applet3D : cet exemple crée la forme 3D d'un vase à partir de son profil pour tester la classe AxisShape.

import javax.media.j3d.*;
import javax.vecmath.*;
import com.sun.j3d.utils.applet.MainFrame;

 
public class AxisShapeDemo extends Applet3D
{
  public BranchGroup createSceneTree ()
  {
    // Racine de l'arbre des objets représentés dans la scène 3D
    BranchGroup root = new BranchGroup ();
 
    // Création d'un vase à partir de son profil
    AxisShape shape = new AxisShape (new Point2f [] {new Point2f (0, 0.7f), 
                                                     new Point2f (0.2f, 0.7f), 
                                                     new Point2f (0.15f, 0.65f), 
                                                     new Point2f (0.15f, 0.55f), 
                                                     new Point2f (0.3f, 0.1f), 
                                                     new Point2f (0.3f, -0.4f), 
                                                     new Point2f (0.1f, -0.63f), 
                                                     new Point2f (0.3f, -0.7f), 
                                                     new Point2f (0, -0.7f)}, 
                                     16);
 
    // Construction de la  branche de l'arbre de la scène
    root.addChild (shape);
 
    return root;
  }
 
  // Méthode main () pour permettre d'utiliser cette classe 
  // comme applet ou comme application
  public static void main (String [] args) 
  {
    new MainFrame (new AxisShapeDemo (), args, 150, 150);
  }  
}

La classe javax.media.j3d.Text3D

Cette classe dérive des classes SceneGraphObject, NodeComponent, Geometry et permet de créer une construction géométrique de texte 3D à partir d'une chaîne de caractères. Ce texte est dessiné avec une police de caractères 3D de classe Font3D à la position donnée dans le plan (x,y) et élevé suivant l'axe z.
Voir aussi l'applet TextTranslation pour un exemple de génération de texte sur plusieurs lignes.

Champs

public static final int ALIGN_FIRST
public static final int ALIGN_CENTER
public static final int ALIGN_LAST

Ces constantes sont utilisées pour aligner le texte sur son premier caractère, au centre ou sur son dernier caractère par rapport à la position du texte.

public static final int PATH_LEFT
public static final int PATH_RIGHT
public static final int PATH_UP
public static final int PATH_DOWN

Ces constantes sont utilisées pour indiquer le sens d'écriture du texte (vers la gauche, la droite, le haut ou le bas).

public static final int ALLOW_STRING_READ
public static final int ALLOW_STRING_WRITE
public static final int ALLOW_FONT3D_READ
public static final int ALLOW_FONT3D_WRITE
public static final int ALLOW_POSITION_READ
public static final int ALLOW_POSITION_WRITE
public static final int ALLOW_ALIGNMENT_READ
public static final int ALLOW_ALIGNMENT_WRITE
public static final int ALLOW_PATH_READ
public static final int ALLOW_PATH_WRITE
public static final int ALLOW_CHARACTER_SPACING_READ
public static final int ALLOW_CHARACTER_SPACING_WRITE

Ces capacités permettent d'autoriser la lecture ou la modification de la chaîne de caractères de ce texte 3D, de sa police de caractères, de sa position, de son alignement, du sens d'écriture ou de l'espacement entre ses caractères.

public static final int ALLOW_BOUNDING_BOX_READ

Cette capacité permet d'autoriser l'interrogation de la boite englobante de ce texte 3D.

Constructeurs

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

Ces constructeurs permettent de créer un texte 3D à partir de la chaîne de caractères string positionnée au point position en utilisant la police de caractères font3D, l'alignement alignment et le sens d'écriture path. Par défaut, font3D est égal à null, string à null, position à (0, 0, 0), alignment à ALIGN_FIRST et path à PATH_RIGHT.

Principales méthodes

public String getString ()	(capacité ALLOW_STRING_READ)
public void setString (String string)	(capacité ALLOW_STRING_WRITE)

Ces méthodes permettent d'interroger ou de modifier la chaîne de caractères affichée par ce texte 3D.

public Font3D getFont3D ()	(capacité ALLOW_FONT3D_READ)
public void setFont3D (Font3D font3d)	(capacité ALLOW_FONT3D_WRITE)

Ces méthodes permettent d'interroger ou de modifier la police de caractères de ce texte 3D.

public void getPosition (Point3f position)	(capacité ALLOW_POSITION_READ)
public void setPosition (Point3f position)	(capacité ALLOW_POSITION_WRITE)

Ces méthodes permettent d'interroger ou de modifier la position de ce texte 3D. Le texte est aligné sur le premier caractère, au centre ou sur le dernier caractère par rapport à ce point suivant l'alignement utilisé.
Si le sens d'écriture est horizontal, la ligne de base du texte est alignée verticalement sur ce point. Si le sens d'écriture est vertical, le texte est alignée à gauche de ce point.

public int getAlignment ()	(capacité ALLOW_ALIGNMENT_READ)
public void setAlignment (int alignment)	(capacité ALLOW_ALIGNMENT_WRITE)

Ces méthodes permettent d'interroger ou de modifier l'alignement de ce texte 3D. alignment peut être égal à ALIGN_FIRST, ALIGN_CENTER ou ALIGN_LAST.

public int getPath ()	(capacité ALLOW_PATH_READ)
public void setPath (int path)	(capacité ALLOW_PATH_WRITE)

Ces méthodes permettent d'interroger ou de modifier le sens d'écriture de ce texte 3D. path peut être égal à PATH_LEFT, PATH_RIGHT, PATH_UP ou PATH_DOWN.

public float getCharacterSpacing ()	(capacité ALLOW_CHARACTER_SPACING_READ)
public void setCharacterSpacing (float characterSpacing)	(capacité ALLOW_CHARACTER_SPACING_WRITE)

Ces méthodes permettent d'interroger ou de modifier l'espacement entre caractères de ce texte 3D. Cette distance est l'espace supplémentaire ajouté entre chaque caractère du texte. Une valeur de 1 correspond au plus large des caractères dans la police utilisée. Par défaut, cet espacement vaut 0.

public void getBoundingBox (BoundingBox bounds)

(capacité ALLOW_BOUNDING_BOX_READ)

Met à jour le paramètre bounds avec les coordonnées de la boite englobante de ce texte 3D.

Voici l'applet HelloWorld3D dérivant de la classe Applet3D. Cet exemple dessine le texte "Hello World 3D" en 3D :

import java.awt.Font;
import javax.media.j3d.*;
import javax.vecmath.*;
import com.sun.j3d.utils.applet.MainFrame;
  
public class HelloWorld3D extends Applet3D
{
  public BranchGroup createSceneTree ()
  {
    // Racine de l'arbre des objets représentés dans la scène 3D
    BranchGroup root = new BranchGroup ();
    
    Font3D font = new Font3D (new Font ("Helvetica", Font.PLAIN, 1), 
                              new FontExtrusion ());
    // Création d'un texte centré sur l'origine
    Text3D textGeometry = new Text3D (font, "Hello World 3D");
    textGeometry.setAlignment (Text3D.ALIGN_CENTER);
    Shape3D textShape = new Shape3D (textGeometry);
    
    // Création d'une rotation de -PI / 4 autour de l'axe x
    Transform3D transform = new Transform3D ();
    transform.rotX (-Math.PI / 6);
    // Création d'une déformation pour voir le texte entièrement à l'écran
    Transform3D scale = new Transform3D ();
    scale.setScale (0.25);
    // Multiplication des deux transformations pour les cumuler
    transform.mul (scale);
    TransformGroup transformGroup = new TransformGroup (transform);
 
    // Construction de la  branche de l'arbre de la scène
    transformGroup.addChild (textShape);
    root.addChild (transformGroup);
    
    return root;
  }
 
  // Méthode main () pour permettre d'utiliser cette classe 
  // comme applet ou comme application
  public static void main (String [] args) 
  {
    new MainFrame (new HelloWorld3D (), args, 300, 70);
  }  
}

Autre exemple

Applet TextTranslation.

La classe javax.media.j3d.Font3D

Cette classe représente une police de caractères 3D, créée à partir d'une police de caractères AWT de classe java.awt.Font et une instance de FontExtrusion qui définit le profil des caractères dans la profondeur. La hauteur du texte 3D est celle de la police de caractères utilisée à l'instantiation de la classe java.awt.Font.

Principal constructeur

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

Exemple

Applet HelloWorld3D, TextTranslation.

La classe javax.media.j3d.FontExtrusion

Cette classe est utilisée par la classe Font3D pour définir le profil des caractères dans la profondeur (suivant l'axe z).

Principaux constructeurs

public FontExtrusion ()
public FontExtrusion (java.awt.Shape extrusionShape)

Ces constructeurs définissent le profil des caractères. Par défaut, c'est une ligne de 0.2 unité de haut.

Exemple

Applet HelloWorld3D, TextTranslation.

Les fonds d'écran

La classe javax.media.j3d.Background

Cette classe dérive des classes SceneGraphObject, Node, Leaf et représente le fond d'écran d'une scène 3D. L'ajout d'une instance de Background dans l'arbre d'une scène 3D permet de changer la couleur noir de fond utilisée par défaut. Ce fond est toujours dessiné en premier avant le reste de la scène 3D, et peut être une couleur unie ou une image associée éventuellement à une sous-scène. Il est représenté par un noeud dans l'arbre d'une scène 3D.

Les fonds d'écran sont appliqués à un espace limité. Cette limite (application bounds), null par défaut, permet d'avoir plusieurs fonds d'écran actifs sur des zones différentes. Il faut obligatoirement déterminer cette limite pour que le fond d'écran soit pris en compte.

Champs (constantes de capacité)

public static final int ALLOW_COLOR_READ
public static final int ALLOW_COLOR_WRITE
public static final int ALLOW_IMAGE_READ
public static final int ALLOW_IMAGE_WRITE
public static final int ALLOW_GEOMETRY_READ
public static final int ALLOW_GEOMETRY_WRITE

Ces capacités permettent d'autoriser la lecture ou la modification de la couleur, de l'image ou de l'arbre de la sous-scène utilisés pour le fond d'écran.

public static final int ALLOW_APPLICATION_BOUNDS_READ
public static final int ALLOW_APPLICATION_BOUNDS_WRITE

Ces capacités permettent d'autoriser la lecture ou la modification des limites dans lesquelles est appliqué le fond d'écran.

Constructeurs

public Background ()
public Background (Color3f color)
public Background (float r, float g, float b)
public Background (ImageComponent2D image)
public Background (BranchGroup branch)

Ces constructeurs permettent de créer un fond d'écran de couleur unie color (ou r g b), utilisant une image image ou une sous-scène branch. Par défaut, color est égal au noir, image et branch à null.

Principales méthodes

public void getColor (Color3f color)	(capacité ALLOW_COLOR_READ)
public void setColor (Color3f color)	(capacité ALLOW_COLOR_WRITE)
public void setColor (float r, float g, float b)	(capacité ALLOW_COLOR_WRITE)

Ces méthodes permettent d'interroger ou de modifier la couleur du fond d'écran.

public ImageComponent2D getImage ()	(capacité ALLOW_IMAGE_READ)
public void setImage (ImageComponent2D image)	(capacité ALLOW_IMAGE_WRITE)

Ces méthodes permettent d'interroger ou de modifier l'image du fond d'écran. Si une image est utilisée, la couleur n'est plus prise en compte.

public BranchGroup getGeometry ()	(capacité ALLOW_GEOMETRY_READ)
public void setGeometry (BranchGroup branch)	(capacité ALLOW_GEOMETRY_WRITE)

Ces méthodes permettent d'interroger ou de modifier l'arbre de la sous-scène du fond d'écran. Cette scène est dessinée par dessus la couleur ou l'image de fond. Elle est projetée à l'infini et doit tenir dans une sphère d'une unité de rayon.

public Bounds getApplicationBounds ()	(capacité ALLOW_APPLICATION_BOUNDS_READ)
public BoundingLeaf getApplicationBoundingLeaf ()	(capacité ALLOW_APPLICATION_BOUNDS_READ)
public void setApplicationBounds (Bounds region)	(capacité ALLOW_APPLICATION_BOUNDS_WRITE)
public void setApplicationBoundingLeaf              (BoundingLeaf region)	(capacité ALLOW_APPLICATION_BOUNDS_WRITE)

Ces méthodes permettent d'interroger ou de modifier la limite dans lesquelles est appliqué le fond d'écran.

Exemples

Applets SimpleObjects, ObjectFileDemo, SimpleTexturedObjects, LightEffect, SunEarthMoonMotion.

La classe javax.media.j3d.Bounds

Cette classe abstract est la super classe des classes BoundingBox, BoundingSphere et BoundingPolytope. Ces classes représentent en Java 3D les limites spatiales utilisées notamment pour les fonds d'écran, l'éclairage et les comportements. La classe Bounds déclare un ensemble de méthodes abstract non décrites ici qui permettent de calculer la combinaison ou l'intersection d'un ensemble de limites.

La classe javax.media.j3d.BoundingBox

Cette classe dérive de la classe Bounds et représente une limite parallélépipédique spécifiée par deux coins opposés de la limite.

Principaux constructeurs

public BoundingBox ()
public BoundingBox (Point3d lower, Point3d upper)

Ces constructeurs permettent de créer une limite parallélépipédique dont les deux points opposés sont lower et upper (par défaut égaux aux points (-1,-1,-1) et (1,1,1)).

Principales méthodes

public void getLower (Point3d p1)
public void getUpper (Point3d p1)
public void setLower (double xmin, double ymin, double zmin)
public void setLower (Point3d p1)
public void setUpper (double xmax, double ymax, double zmax)
public void setUpper (Point3d p1)

Ces méthodes permettent d'interroger ou de modifier les deux points opposés de cette limite.

Exemples

Applets SimpleObjects, ObjectFileDemo, SimpleTexturedObjects, LightEffect.

La classe javax.media.j3d.BoundingSphere

Cette classe dérive de la classe Bounds et représente une limite sphérique.

Principaux constructeurs

public BoundingSphere ()
public BoundingSphere (Point3d center, double radius)

Ces constructeurs permettent de créer une limite sphérique centrée en center et de rayon radius (par défaut égaux à l'origine et 1).

Principales méthodes

public double getRadius ()
public void getCenter (Point3d center)
public void setRadius (double r)
public void setCenter (Point3d center)

Ces méthodes permettent d'interroger ou de modifier la rayon ou le centre de cette limite.

Exemples

Applets LightEffect, LitApplet3D, MouseApplet3D, TextTranslation, AlphaTest, TextTranslation, Clock3D, SunEarthMoonMotion.

La classe javax.media.j3d.BoundingLeaf

Cette classe dérive des classes SceneGraphObject, Node, Leaf. Ce type de noeud qui mémorise une limite spatiale de classe Bounds peut être partagé par un ensemble de noeuds d'un arbre 3D ayant besoin d'une limite. Ceci évite de créer une instance de limite pour chaque noeud de cet ensemble . Par exemple, une instance de la classe BoundingLeaf peut représenter les limites d'une pièce qui seront utilisées par les sources lumineuses et sonores de cette pièce. Une instance de cette classe est représentée par un noeud dans l'arbre d'une scène 3D.
N'oubliez pas d'ajouter les instances de la classe BoundingLeaf à l'arbre de la scène 3D, pour que Java 3D puisse prendre en compte les groupes de transformations parents susceptibles de modifier la limite associée.

Champs (constantes de capacité)

public static final int ALLOW_REGION_READ
public static final int ALLOW_REGION_WRITE

Ces capacités permettent d'autoriser la lecture ou la modification de la limite.

Constructeurs

public BoundingLeaf ()
public BoundingLeaf (Bounds region)

Ces constructeurs permettent de créer une limite (region est égal à null par défaut).

Principales méthodes

public Bounds getRegion ()	(capacité ALLOW_REGION_READ)
public void setRegion (Bounds region)	(capacité ALLOW_REGION_WRITE)

Ces méthodes permettent d'interroger ou de modifier la limite de cet instance.

Exemple

Applet Clock3D.

L'importation de scènes 3D

La programmation d'une scène 3D est souvent longue et n'est pas toujours la manière la plus simple pour subvenir à tous les besoins d'un programme. Java 3D fournit le package com.sun.j3d.loaders avec les interfaces Loader et Scene dont l'implémentation vise à permettre l'importation de fichiers créés avec d'autres logiciels 3D : ceci permet de mettre en scène dans Java 3D des objets 3D issus de bibliothèques existantes ou de créer vos objets avec un logiciel 3D pour l'importer ensuite dans Java 3D.
Java 3D fournit deux classes implémentant ces interfaces :

com.sun.j3d.loaders.objectfile.ObjectFile	Fichiers .obj Wavefront
com.sun.j3d.loaders.lw3d.Lw3dLoader	Fichiers .lws Lightwave 3D

Les éditeurs de logiciels 3D fournissent le même type de classe pour la plupart des autres formats de fichiers.

Voici l'applet ObjectFileDemo dérivant de la classe Applet3D : cet exemple affiche le fichier p51_mustang.obj fourni avec les exemples de Java 3D. Sans effet d'éclairage, les formes 3D définies dans ce fichier sont noires, c'est pourquoi un fond bleu est ajouté à la scène 3D.

import javax.media.j3d.*;
import com.sun.j3d.loaders.objectfile.ObjectFile;
import com.sun.j3d.loaders.Scene;
import com.sun.j3d.utils.applet.MainFrame;
 
public class ObjectFileDemo extends Applet3D
{
  public BranchGroup createSceneTree ()
  {
    // Racine de l'arbre des objets représentés dans la scène 3D
    BranchGroup root = new BranchGroup ();
      
    // Création d'un fond bleu ciel pour apercevoir l'avion qui est noir par défaut
    Background background = new Background (0.4f, 0.6f, 0.8f);
    background.setApplicationBounds (new BoundingBox ());
    root.addChild (background);

    try 
    {
      // Chargement du fichier p51_mustang.obj
      ObjectFile loader = new ObjectFile ();
      Scene scene = loader.load ("p51_mustang.obj");
      BranchGroup objectRoot = scene.getSceneGroup ();
       
      // Création d'une rotation de PI / 6 autour de l'axe x
      Transform3D transform = new Transform3D ();
      transform.rotX (Math.PI / 6);
      // Modification de l'échelle 
      transform.setScale (0.1);
      TransformGroup transformGroup = new TransformGroup (transform);
 
      transformGroup.addChild (objectRoot);
      root.addChild (transformGroup);
    }
    catch (Exception e) 
    {
      System.err.println (e);
    }    
    
    return root;
  }
 
  // Méthode main () pour permettre d'utiliser cette classe 
  // comme applet ou comme application
  public static void main (String [] args) 
  {
    new MainFrame (new ObjectFileDemo (), args, 150, 120);
  }  
}

Figure 13. Arbre de la scène ObjectFileDemo

L'interface com.sun.j3d.loaders.Loader

Cette interface est implémentée pour importer des sources de données 3D.
Les exceptions Runtime de classes IncorrectFormatException et ParsingErrorException sont déclenchées par les méthodes load () pour indiquer respectivement que les données ne sont pas au format attendu ou que la lecture des données à rencontrer un problème.

Champs

public static final int LOAD_BACKGROUND_NODES
public static final int LOAD_LIGHT_NODES
public static final int LOAD_FOG_NODES
public static final int LOAD_SOUND_NODES
public static final int LOAD_BEHAVIOR_NODES
public static final int LOAD_VIEW_GROUPS
public static final int LOAD_ALL

Ces constantes ou une combinaison de ces constantes sont passées en paramètre à la méthode setFlags () pour indiquer quelles parties de la scène doit être chargée.

Méthodes

public int getFlags ()
public void setFlags (int flags) 

Ces méthodes permettent d'interroger ou de modifier les indicateurs de chargement flags. flags peut être égal à l'une des constantes LOAD_... ou à la combinaison de ces constantes avec l'opérateur |, et indiquent quelle partie de la scène doit être chargée.

public Scene load (String fileName) 
                throws java.io.FileNotFoundException, IncorrectFormatException, 
                       ParsingErrorException 
public String getBasePath ()
public void setBasePath (String pathName)

La méthode load () permettent de charger une scène à partir du fichier fileName. Les méthodes getBasePath () et setBasePath () permettent d'interroger ou de modifier le chemin utilisé pour trouver les éventuels fichiers référencés par le contenu de fileName. Par défaut, ce chemin est le même répertoire que celui du fichier fileName.

public Scene load (java.net.URL url)
                throws java.io.FileNotFoundException, IncorrectFormatException, 
                       ParsingErrorException 
public java.net.URL getBaseUrl ()
public void setBaseUrl (java.net.URL url)

La méthode load () permettent de charger une scène à partir de l'URL url. Les méthodes getBaseUrl () et setBaseUrl () permettent d'interroger ou de modifier le chemin utilisé pour trouver les éventuels fichiers référencés par le contenu d'url. Par défaut, ce chemin est le même répertoire que celle de l'url.

public Scene load (java.io.Reader reader)
                throws java.io.FileNotFoundException, IncorrectFormatException, 
                       ParsingErrorException 

Charge une scène à partir de la source de données reader. Le chemin utilisé pour trouver les éventuels fichiers référencés par le contenu de reader est le répertoire courant de l'utilisateur (issu de la propriété système user.dir).

Exemple

Applet ObjectFileDemo.

L'interface com.sun.j3d.loaders.Scene

Cette interface permet d'interroger les différentes parties d'une scène 3D importée par les méthodes load () de la classe implémentant l'interface Loader.

Méthodes

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

Ces méthodes permettent d'interroger les différentes parties de la scène 3D. L'instance de la classe BranchGroup renvoyée par getSceneGroup () peut être directement rattachée à une instance de SimpleUniverse.

Exemple

Applet ObjectFileDemo.

© Copyrights 1997-2023 Emmanuel PUYBARET / eTeks - Tous droits réservés -