Java3D tutoriel:

Chapitre 1: la Théorie

Nous contacter

Nous allons ici essayer de vous faire comprendre comment il faut concevoir votre monde 3D pour l'intégrer à Java3D.
L'orientation de java3D au modèle objet a induit sa représentation sous forme d'un arbre sans cycle. C'est un graphe formé de noeuds et d'arcs, où un noeud ne pointe jamais vers l'un de ses parents (direct ou non), et où un noeud n'a jamais plusieurs pères.

La racine de l'arbre est votre univers virtuel auquel vous rattachez un point de référence qui va servir de repère pour placer vos différents objets.

Détaillons un peu la structure d'un objet en java3D.

Un objet peut être vu comme un regroupement d'objets élémentaires. Chaque objet élémentaire est issu de l'association d'une géométrie ( ensemble de faces trianglulaires ou de primitives) et d'une apparence (couleur, transparence, texture). Java3D fournit les primitives suivantes: sphere, boîte, cône et cylindre; mais vous pouvez contruire vos objets point par point grâce aux vertex.
Pour construire des objets complexes vous allez avoir besoin de les placer les uns par rapport aux autres, c'est l'utilité des Groupes de Transformation correspondant à la classe TransformGroup. Lorsque vous construisez un objet à l'aide de primitives, celà se fait toujours par rapport a un repère relatif et nous vous conseillons de faire de même lorsque vous manipulez les vertex. Les TransformGroup vous serviront donc à placer les objets dans ce repère. Plus tard, vous verrez que ces mêmes TransformGroup sont utilisés pour créer des animations. Les TransformGroup vous permettent de faire des translations et des rotations: vous pouvez en chaîner autant que vous le souhaitez. Enfin, lorsque vous avez construit tous vos objets, vous pouvez définir un rassemblement d 'objets correspondant à la classe BranchGroup.Vous pouvez relier autant de BranchGroup que vous le souhaitez ( un au minimum) au point de référence.

Voici un schéma qui résume l'organisation d'une scène 3D en Java3D

Création placement et apparence des primitives

Comme nous l'avons écrit plus haut, nous allons essayer de vous montrer le maximum de points importants, de façon progressive, au travers d' exemples didactiques.

Les schémas utilisés sont la pour que vous visualisiez la construction de l'arbre que constitue votre scène en Java 3D. Il verifie la légende suivante


Tout d'abord, nous allons étudier la structure minimale d'un programme en java 3D, ce qui permettra de mettre en application le modèle général vu plus haut.
La premiere classe utilisée est Canvas3D qui est dérivée de Canvas ( donc même utilisation ) et qui nous sert juste à afficher du java3D.
Les classes utilisées sont SimpleUniverse qui représente vore univers 3d et qui va contenir tout votre scène. C'est en fait un univers qui a ses paramètres préconfigurés pour simplifier le code. Nous n'avons jamais vu d'autre exemple d'univers dans le tutoriel de Sun, aussi nous n'utiliserons que celui-ci. Nous ne configurons que la caméra. Notre univers contiendra un seul regroupement d'objets qui correspond à la classe BranchGroup (BG), et ce BG ne contiendra qu'un seul objet ( classe Shape3D) qui est la classe ColorCube qui a une géométrie et une apparence prédéfinie. Pour associer notre objet ( Shape3D ), il faut créer un lien d'héritage entre le BG et la Shape3D, ce lien se fait grace à la méthode addChild().
Télécharger la source
cube3D.java


Légende

Organisation générale


// classes Java standart
import java.awt.Frame;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.awt.BorderLayout;
// classes Java 3d
import com.sun.j3d.utils.universe.SimpleUniverse;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.BranchGroup;
import com.sun.j3d.utils.geometry.ColorCube;

public class cube3d extends Applet
{

public cube3d()
{

super("- un cube vue de face -");
this.addWindowListener(this);


setLayout(new BorderLayout());
// 1ere étape création du Canvas3d qui va afficher votre univers virtuel avec une config prédéfinie
Canvas3D canvas3D = new Canvas3D(SimpleUniverse.getPreferredConfiguration());
add("Center", canvas3D);
// 2eme étape on crée notre scène (regroupement d'objets)
BranchGroup scene = createSceneGraph();
// on les compile pour optimiser les calculs
scene.compile();

// 3eme étape on crée l'univers qui va contenir notre scène 3d
// utilise simpleUniverse qui simplifie le code (il crée un environnement minimal simple)
SimpleUniverse simpleU = new SimpleUniverse(canvas3D);
// on met le plan de projection en arriere par rapport à l'origine
simpleU.getViewingPlatform().setNominalViewingTransform();
// on place la scène dans l'univers simpleU simpleU.addBranchGraph(scene);

}

//crée un regroupement d'objets contenant un objet cube
public BranchGroup createSceneGraph()
{

//on crée le Bg principal
BranchGroup objRoot=new BranchGroup();

// on crée un cube
objRoot.addChild(new ColorCube(0.5));// de rayon 50 cm
return objRoot;

}

public void windowActivated(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowOpened(WindowEvent e){}

public void windowClosing(WindowEvent e) {  System.exit(1); }

public static void main(String[] args)
{

cube3d myApp=new cube3d();
myApp.setSize(300,300);
myApp.setVisible(true);

}

}


Comme vous pouvez le constater, nous ne pouvons voir qu'une face de notre cube, ce qui ne le met pas tellement en valeur.
Nous allons donc apprendre à manipuler les groupes de transformation :TransformGroup ( TG ) pour positionner notre cube de façon à voir trois de ces faces.
Pour cela nous avons besoin de la classe Transform3D qui est en fait une matrice pouvant définir des translations ou des rotations. A partir de cette matrice, nous pouvons créer un TG. Or les TG peuvent également enfanter 'une Shape3D et peuvent etre reliés à un BG ( voir schéma d'organisation), c'est ce qui permet de placer les objets où on le souhaite. Télécharger la source cube3dTG.java


Organisation générale

 

// classes Java standard
import java.awt.Frame;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.awt.BorderLayout;
// classes Java 3D
import com.sun.j3d.utils.universe.SimpleUniverse;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.BranchGroup;
import com.sun.j3d.utils.geometry.ColorCube;
import javax.media.j3d.TransformGroup;
import javax.media.j3d.Transform3D;

public class cube3dTG extends Frame implements WindowListener
{

public cube3dTG()
{

super("- un TG pour orienter le cube -");
this.addWindowListener(this);
setLayout(new BorderLayout());
// 1ere étape création du Canvas3d qui va afficher votre univers virtuel avec une config prédéfinie
Canvas3D canvas3D = new Canvas3D(SimpleUniverse.getPreferredConfiguration());
add("Center", canvas3D);
// 2eme étape on crée notre scène (regroupement d'objets)
BranchGroup scene = createSceneGraph();
// on les compile pour optimiser les calculs
scene.compile();

// 3eme étape on créer l'univers qui va contenir notre scène 3d
// utilise simpleUniverse qui simplifie le code (il crée un environemment minimal simple)
SimpleUniverse simpleU = new SimpleUniverse(canvas3D);
// on met le plan de projection en arriere par rapport à l'origine
simpleU.getViewingPlatform().setNominalViewingTransform();
// on place la scene dans l'univers simpleU simpleU.addBranchGraph(scene);

}

//crée un regroupement d'objets contenant un objet cube
public BranchGroup createSceneGraph()
{

//on crée le Bg principal
BranchGroup objRoot=new BranchGroup();

// on crée une matrice de tranformation pour faire tourner notre cube
Transform3D rotate = new Transform3D();
// (X represente l' horizontale orientée vers la droite,Y represente la vericale orientée vers le haut,Z pointe sur vous)
// les rotations s'effectuent en prenant l'axe choisi comme axe de rotation dans le sens trigonométrique (inverse de celui des aiguilles d'une montre)
rotate.rotX(Math.PI/3.0d);//rotation d'angle Pi/3

// on crée un groupe de transformation rotate suivant la matrice de transformation rotate
TransformGroup objRotate = new TransformGroup(rotate);

// on crée un cube qui herite de cette rotation
objRotate.addChild(new ColorCube(0.5));// de rayon 50 cm

//on ajout de notre objet objRotate a notre groupe d'objets ( qui ne contient qu'un cube dans notre cas )
objRoot.addChild(objRotate);

return objRoot;

}

public void windowActivated(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowOpened(WindowEvent e){}

public void windowClosing(WindowEvent e) {  System.exit(1); }

public static void main(String[] args)
{

cube3dTG myApp=new cube3dTG();
myApp.setSize(300,300);
myApp.setVisible(true);

}

}


Nous allons maintenant voir comment, à l'aide des TransformGroup, on peut positionner deux objets l'un par rapport à l'autre. Nous détaillons ici les 3 utilisations principales de la classe Transform3D qui permet de faire des translations, des rotations ( voir le schéma repère ), et de retailler vos objets. Faites attention, une instance d'un objet ( Shape3D ) ne peut pas être reférencée par deux TransformGroup ou BranchGroup. Par contre plusieurs Shape3D peuvent très bien avoir le même BG ou TG. Il faut créer une instance de la Shape3D pour chaque TransformGroup ou BranchGroup. Télécharger la source cube3d2.java


Repère

Organisation générale

//Java standart API
import java.awt.Frame;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.awt.BorderLayout;
//Java 3d API
import com.sun.j3d.utils.universe.SimpleUniverse;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.TransformGroup;
import javax.media.j3d.Transform3D;
import javax.vecmath.Vector3f;
import com.sun.j3d.utils.geometry.ColorCube;

// attention vous ne pouvez pas utiliser un même objet (shape3d), comme notre cube, dans plusieurs Group de transformation
// il faut créer 2 entités distinctes comme nous l'avons fait

public class cube3d2 extends Applet
{

public cube3d2()
{

super("- 2 TG pour placer 2 cubes -");
this.addWindowListener(this);
setLayout(new BorderLayout());
// 1ere étape création du Canvas3d qui va afficher votre univers virtuel avec une config préetablie
Canvas3D canvas3D = new Canvas3D(SimpleUniverse.getPreferredConfiguration());
add("Center", canvas3D);
// 2eme étape on crée notre scene (regroupement d'objets)
BranchGroup scene = createSceneGraph();
// on les compile pour optimiser les calculs
scene.compile();

// 3eme étape on crée l'univers qui va contenir notre scène 3d
// utilise simpleUniverse qui simplifie le code (il crée un environnement minimal simple)
SimpleUniverse simpleU = new SimpleUniverse(canvas3D);
// on met le plan de projection en arriere par rapport àl'origine
simpleU.getViewingPlatform().setNominalViewingTransform();
// on place la scène dans l'univers simpleU simpleU.addBranchGraph(scene);

}

//crée un regroupement d'objets contenant un objet cube
public BranchGroup createSceneGraph()
{

//on crée le Bg principal
BranchGroup objRoot=new BranchGroup();

//------------ début de creation du premier cube ------------

// on crée un vecteur de translation 30 cm suivant les Y
Transform3D translate1 = new Transform3D();
translate1.set(new Vector3f(0.4f, 0.4f, 0.0f));

// on crée une matrice de tranformation pour faire tourner notre cube
Transform3D rotate = new Transform3D();
//(X represente la vericale orientée vers le bas,Y represente l' horizontale orientée vers la gauche,Z) rotate.rotX(Math.PI/3.0d);//rotation d'angle Pi/3

// on combine les deux transformations: translation puis rotation
translate1.mul(rotate);
// on crée un groupe de transformation rotate suivant la matrice de transformation translate1 TransformGroup TG1 = new TransformGroup(translate1);

// on crée un cube qui herite de cette rotation
TG1.addChild(new ColorCube(0.3));// de rayon 30 cm
objRoot.addChild(TG1);

//------------ fin de creation du premier cube ------------
//------------ début de creation du deuxieme cube ------------

// on crée un vecteur de translation de 30 cm suivant les Y (dans l'autre sens)
Transform3D translate2 = new Transform3D();
translate2.set(new Vector3f(-0.4f, -0.4f, 0.0f));

// on crée une matrice de tranformation pour faire tourner notre cube
Transform3D rotate2 = new Transform3D();
rotate2.rotZ(Math.PI/3.0d);//rotation d'angle Pi/3

// on combine les deux transformations: translation puis rotation
translate2.mul(rotate2);

// on réduit la taille du cube par 2 (on la multiplie par 0.5)
translate2.setScale(0.5f);

// on crée un groupe de transformation rotate suivant la matrice de transformation translate1
TransformGroup TG2 = new TransformGroup(translate2);

// on crée un cube qui herite de cette rotation
TG2.addChild(new ColorCube(0.3));// de rayon 20 cm

objRoot.addChild(TG2);

//------------ fin de creation du deuxieme cube ------------

return objRoot;

}

public void windowActivated(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowOpened(WindowEvent e){}

public void windowClosing(WindowEvent e) {  System.exit(1); }

public static void main(String[] args)
{

cube3d2 myApp=new cube3d2();
myApp.setSize(300,300);
myApp.setVisible(true);

}

}


Maintenant que l'on sait manipuler des objets, nous allons découvrir les différentes primitives que nous offre le java3D ainsi que le contrôle basic de leurs apparences. Les apparences correspondent à la classe Appareance: pour définir une couleur, nous devons utilser la classe ColoringAttributes, spécifier sa couleur et son mode de rendu (FASTEST, NICEST, SHADE_FLAT, ou SHADE_GOURAUD ). Dans les primitives, la liaison (par référence ) entre géometrie et apparence est faite chez le constructeur; vous n'aurez donc pas encore à vous en soucier. En effet jusqu'à présent, nous utilisions la classe ColorCube() qui avait déja une apparence préconfigurée: Télécharger la source objet3d.java


Organisation générale

// classes Java standard
import java.awt.Frame;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.awt.BorderLayout;
import java.awt.Font;
// classes Java 3D
import com.sun.j3d.utils.universe.SimpleUniverse;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.TransformGroup;
import javax.media.j3d.Transform3D;
import javax.media.j3d.Text3D;
import javax.media.j3d.ColoringAttributes;
import javax.media.j3d.Font3D;
import javax.media.j3d.Appearance;
import javax.media.j3d.FontExtrusion;
import javax.media.j3d.Shape3D;
import javax.media.j3d.Background;
import javax.media.j3d.BoundingSphere;
import javax.vecmath.Point3f;
import javax.vecmath.Vector3f;
import com.sun.j3d.utils.geometry.Cone;
import com.sun.j3d.utils.geometry.Box;
import com.sun.j3d.utils.geometry.Sphere;

public class objet3d extends Applet
{

public objet3d()
{

super("- 4 primitives aux apparences simples -");
this.addWindowListener(this);
setLayout(new BorderLayout());
// 1ere étape création du Canvas3d qui vas afficher votre univers virtuel avec une config prédéfinie
Canvas3D canvas3D = new Canvas3D(SimpleUniverse.getPreferredConfiguration());
add("Center", canvas3D);
// 2eme étape on crée notre scene (regroupement d'objets)
BranchGroup scene = createSceneGraph();
// on les compile pour optimiser les calculs
scene.compile();

// 3eme étape on cree l'univers qui va contenir notre scene 3d
// utilise simpleUniverse qui simplifie le code (il crée un environemment minimal simple)
SimpleUniverse simpleU = new SimpleUniverse(canvas3D);
// on met le plan de projection en arriere par rapport à l'origine
simpleU.getViewingPlatform().setNominalViewingTransform();
// on place la scene dans l'univers simpleU simpleU.addBranchGraph(scene);

}

//crée un regroupement d'objetst contenant un objet cube
public BranchGroup createSceneGraph()
{

//on crée le Bg principal
BranchGroup objRoot=new BranchGroup();

//------------ debut création des apparences ------------

// on crée une apparence de couleur bleue
Appearance app_bleu = new Appearance();
ColoringAttributes bleu=new ColoringAttributes();
bleu.setColor(0.1f,0.1f,1.0f);
// on précise le rendu
bleu.setShadeModel(ColoringAttributes.NICEST);
app_bleu.setColoringAttributes(bleu);

// on crée une apparence de couleur rouge
Appearance app_rouge = new Appearance();
ColoringAttributes rouge=new ColoringAttributes();
rouge.setColor(1.0f,0.1f,0.1f);
// on précise le rendu
rouge.setShadeModel(ColoringAttributes.NICEST);
app_rouge.setColoringAttributes(rouge);

// on crée une apparence de couleu r verte
Appearance app_vert = new Appearance();
ColoringAttributes vert=new ColoringAttributes();
vert.setColor(0.1f,1.0f,0.1f);
// on precise le rendu
vert.setShadeModel(ColoringAttributes.NICEST);
app_vert.setColoringAttributes(vert);

// on crée une apparence de couleur orange
Appearance app_orang = new Appearance();
ColoringAttributes orang=new ColoringAttributes();
orang.setColor(0.8f,0.4f,0.2f);
// on precise le rendu
orang.setShadeModel(ColoringAttributes.NICEST);
app_orang.setColoringAttributes(orang);

//------------ fin de création des apparences -------------
//------------ début de création de la sphère --------------

// on crée un vecteur de translation 30 cm suivant les Y (dans l'autre sens)
Transform3D translate1 = new Transform3D();
translate1.set(new Vector3f(0.4f, 0.4f, 0.0f));

// on crée un groupe de transformation TG1 suivant la matrice de transformation translate1
TransformGroup TG1 = new TransformGroup(translate1) ;

// on crée un cube qui herite de cette rotation
TG1.addChild(new Sphere(0.3f,app_bleu)); // de rayon 20 cm peinte en bleu

objRoot.addChild(TG1);

//------------ fin de création de la sphère -----------------------
//------------ début de création du cône -------------------------

// on crée un vecteur de translation de 30 cm suivant les Y (dans l'autre sens)
Transform3D translate2 = new Transform3D();
translate2.set(new Vector3f(-0.4f, -0.4f, 0.0f));

// on crée un groupe de transformation TG2 suivant la matrice de transformation translate2
TransformGroup TG2 = new TransformGroup(translate2) ;

// on crée un cube qui herite de cette translation
TG2.addChild(new Cone(0.2f, 0.4f,Cone.ENABLE_APPEARANCE_MODIFY,app_rouge));// de rayon 20 cm et de hauteur 40cm peint en rouge en permettant de modifier son apparence en temps réel (inutilisé ici)

objRoot.addChild(TG2);

//-------------- fin de création du cône -------------------------
//------------ début de création d'une boite ------------

// on crée un vecteur de translation 30 cm suivant les Y
Transform3D translate3 = new Transform3D();
translate3.set(new Vector3f(-0.4f, 0.4f, 0.0f));

// on crée une matrice de tranformation pour faire tourner notre cube
Transform3D rotate = new Transform3D();
rotate.rotZ(2*Math.PI/3.0d);//rotation d'angle 2Pi/3

// on combine les deux transformations: translation puis rotation translate3.mul(rotate); //rotate.mul(translate3);

// on crée un groupe de transformation TG3 suivant la matrice de transformation translate3
TransformGroup TG3 = new TransformGroup(translate3);

// on crée un cube qui herite de cette rotation
TG3.addChild(new Box(0.2f, 0.4f,0.1f,app_orang));// de largeur 40 cm, de hauteur 80cm, de profondeur 20 cm peint en vert

objRoot.addChild(TG3);

//------------ fin de création d'une boite --------------
//------------ début de création d'un texte en 3d------------

// on définit la font 3d dont on va se servir, attention les font sont surdimensiionnées
Font3D my_font=new Font3D(new Font("Helvetica",Font.PLAIN,1),new FontExtrusion());

// on utilise cette font3D pour créer un texte en 3d
Text3D textGeom=new Text3D(my_font,new String("Coucou"),new Point3f(3.0f,-3.0f,0.0f)) ;
textGeom.setAlignment(Text3D.ALIGN_CENTER);

// finalement on transforme ce txt en shape3d avec l'apparence app_vert affichable par java3d //Shape3D text=new Shape3D(textGeom,app_vert); ou bien
Shape3D text=new Shape3D();
text.setGeometry(textGeom);
text.setAppearance(app_vert);

// on réduit la taille du texte car beaucoup trop grande par défaut
Transform3D scale3D = new Transform3D();
scale3D.setScale(0.2f);
TransformGroup scale = new TransformGroup(scale3D);

objRoot.addChild(scale);
scale.addChild(text);

//------------ fin de création d'un texte en 3d--------------

// met le fond en gris
Background background = new Background(0.2f, 0.2f, 0.2f);
background.setApplicationBounds(new BoundingSphere()) ;
objRoot.addChild(background);

return objRoot;

}

public void windowActivated(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowOpened(WindowEvent e){}

public void windowClosing(WindowEvent e) {  System.exit(1); }

public static void main(String[] args)
{

objet3d myApp=new objet();
myApp.setSize(300,300);
myApp.setVisible(true);

}

}


Nous allons maintenant, pour terminer ce chapitre voir comment rendre nos primitives transparentes. Il suffit de spécifier une "TransparencyAttributes" contenant le taux de transparence ( 0=pas de transparence et 1=invisible ) à notre apparence. Télécharger la source sphereTrans.java


Organisation générale

// classes Java standart
import java.awt.Frame;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.awt.BorderLayout;
import java.awt.Font;
// classes Java 3D
import com.sun.j3d.utils.universe.SimpleUniverse;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.TransformGroup;
import javax.media.j3d.Transform3D;
import javax.media.j3d.Text3D;
import javax.media.j3d.ColoringAttributes;
import javax.media.j3d.Font3D;
import javax.media.j3d.Appearance;
import javax.media.j3d.FontExtrusion;
import javax.media.j3d.Shape3D;
import javax.media.j3d.Background;
import javax.media.j3d.BoundingSphere;
import javax.media.j3d.TriangleStripArray;
import javax.media.j3d.TransparencyAttributes;
import javax.vecmath.Point3f;
import javax.vecmath.Vector3f;
import javax.vecmath.Color3f;
import javax.vecmath.Point2f;
import com.sun.j3d.utils.geometry.ColorCube;
import com.sun.j3d.utils.geometry.Sphere;

// nous allons ici creer 2 apparences une texturée et l'autre colorée avec une couche alpha pour la rendre transparente
// attention les textures chargées doivent avoir des dimensions multiples de 2

public class sphereTrans extends Frame implements WindowListener
{

public sphereTrans()
{

super("- intro à la transparence-");
this.addWindowListener(this);
setLayout(new BorderLayout());
// 1ere étape création du Canvas3d qui va afficher votre univers virtuel avec une config prédéfinie
Canvas3D canvas3D = new Canvas3D(SimpleUniverse.getPreferredConfiguration());
add("Center", canvas3D);
// 2eme étape on crée notre scene (regroupement d'objet)
BranchGroup scene = createSceneGraph();
// on les compile pour optimiser les calculs
scene.compile();

// 3eme étape on crée l'univers qui va contenir notre scene 3d
// utilise simpleUniverse qui simplifie le code (il crée un environemment minimal simple)
SimpleUniverse simpleU = new SimpleUniverse(canvas3D);
// on met le plan de projection en arriere par rapport à l'origine
simpleU.getViewingPlatform().setNominalViewingTransform();
// on place la scene dans l'univers simpleU simpleU.addBranchGraph(scene);

}

//crée un regroupement d'objets contenant un objet cube
public BranchGroup createSceneGraph()
{

BranchGroup scene=new BranchGroup();

// on crée une apparence avec une couleur et une couche alpha
  Appearance app0=new Appearance();
  app0.setColoringAttributes(new ColoringAttributes(new Color3f(0.3f,0.2f,1.0f),ColoringAttributes.SHADE_GOURAUD));
  app0.setTransparencyAttributes(new TransparencyAttributes(TransparencyAttributes.NICEST,0.5f));//0.5f represente 50%   de transparence

// on crée un TG pour faire tourner notre cube
  Transform3D rotate = new Transform3D();
  rotate.rotX(Math.PI/3.0d);
  Transform3D rotate2 = new Transform3D();
  rotate2.rotY(Math.PI/3.0d);
  rotate.mul(rotate2);
  // on crée un groupe de transformation rotate suivant la matrice de transformation rotate
  TransformGroup objRotate = new TransformGroup(rotate);

// on crée un cube qui herite de cette rotation
objRotate.addChild(new ColorCube(0.5));// de rayon 50 cm

scene.addChild(objRotate);

// on crée une sphere bleu de transparence 10% devant le cube
Transform3D trans=new Transform3D();
trans.set(new Vector3f(0.3f, -0.3f, 1.0f));
TransformGroup TG=new TransformGroup(trans);
scene.addChild(TG);
TG.addChild( new Sphere(0.3f,app0) );

return scene;

}

public void windowActivated(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowOpened(WindowEvent e){}

public void windowClosing(WindowEvent e) {  System.exit(1); }

public static void main(String[] args)
{

objetText3d myApp=new objetText3d();
myApp.setSize(300,300);
myApp.setVisible(true);

}

}


Maintenant vous pouvez aborder les chapitres suivants:
Chapitre 2: création d'objets à partir d'objet élémentaire
Chapitre 3: animation