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 bleuobjRoot.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 vertobjRoot.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 2public 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);
}
}