Premiers pas avec la librairie Java 3D

Java 3D est une librairie qui est une extension de Java 2. Cette extension fournit tout un ensemble de méthodes permettant de créer « facilement » des applications ou applets graphiques 3D interactives. Elle va servir de lien avec les librairies système, dites de bas niveau, que sont DirectX (sous Windows uniquement) et OpenGL (présent sur la plupart des systèmes d'exploitation dont Windows et Linux). Ces librairies dites de « lien » sont appelées API binding en anglais. La raison pour laquelle j'ai décidé de créer une section spéciale Java 3D est que cette librairie est utilisable à la fois sous DirectX et OpenGL.

DirectX et OpenGL sont des librairies dites de « bas niveau », car elles sont directement liées au matériel, en particulier les cartes graphiques. Aujourd'hui, quasiment toutes les cartes graphiques du marché – et pas seulement le haut de gamme – possèdent des fonctions internes directement cablées pour DirectX et OpenGL. En général, lorsqu'on installe une carte graphique, il faut toujours mettre à jour les pilotes avec la dernière version disponible, car OpenGL est fourni avec. Pour DirectX, il fait désormais partie intégrante de Windows, et les dernières versions et mises à jour peuvent toujours être téléchargées ici sur le site web de Microsoft.

OpenGL et DirectX sont tellement proches du matériel et du système d'exploitation que cela rend leur approche directe extrêmement complexe. Heureusement Java 3D se présente sous un angle beaucoup plus simple et convivial en se chargeant de faire le « pont » entre le développeur d'un côté et le système s'exploitation de l'autre. Les plus curieux qui voudront aller plus loin en 3D en visitant des sites web anglophones sur le sujet verront que les librairies comme Java 3D sont souvent désignées par le terme de wrapper (librairie enveloppe).

La librairie Java 3D ne peut pas fonctionner seule, il est nécessaire d'avoir installé au préalable Java 2. Java 2 comporte une machine virtuelle ainsi que toutes les librairies nécessaires à la création d'applications ou d'applets Java. La version 1.4.2 de Java 2 peut être téléchargée gratuitement ici sur le site web de Sun. Plus récemment, Sun a mis en ligne la version 1.5 (maintenant appelée JDK version 5.0) dite « Tiger » qui peut être téléchargée ici. Pour pouvoir créer vos propres programmes Java, il est nécessaire de télécharger la version J2SE SDK (Java 2 Standard Edition Software Development Kit) qui contient l'intégralité des bibliothèques de programmation, tandis que la version J2SE JRE (Java 2 Standard Edition Java Runtime Environment) ne permet que l'exécution de programmes Java.

Ensuite, il suffit de double cliquer sur le fichier téléchargé et de se laisser guider par le processus d'installation. Toutefois, veillez à ce que le Plug-In Java soit bien enregistré pour le navigateur par défaut, cela permet de faire tourner des applets 3D au sein même du navigateur Internet.

Une fois la procédure terminée, vous serez peut être amené à redémarrer le PC.

La dernière version pour Windows de Java 3D publiée par Sun est la version 1.3.1, elle peut se télécharger ici. Comme nous l'avons vu dans l'introduction, le code source de Java 3D a désormais basculé dans le monde du libre, et une version 1.3.2 (Windows et Linux) peut être téléchargée ici.

À ceux qui tiennent à télécharger la version 1.3.1 de Sun, je conseille fortement de prendre la version OpenGL plutôt que DirectX car certaines fonctionnalités de Java 3D ne sont activées qu'en OpenGL. Cependant, à partir de la version 4.09 des drivers Catalyst pour les cartes ATI, la version OpenGL de Java 3D 1.3.1 ne semble plus fonctionner, il est donc nécessaire dans ce cas de se rabattre sur la version DirectX. La version 1.3.2 résout les problèmes avec les cartes ATI. Ensuite, pour installer la version 1.3.1, il suffit de double cliquer sur l'exécutable précédemment téléchargé et de suivre les instructions affichées à l'écran.

L'installation de la version 1.3.2 est un peu plus compliquée, car il n'y a pas d'installeur automatisé. Il faut décompresser l'archive java3d-1_3_2-windows-i586.zip (Windows) dans un répertoire quelconque, puis décompresser l'archive j3d-132-win.zip dans le répertoire C:\…\j2sdk1.4.2_06\jre (C:\…\j2sdk1.4.2_06 étant le répertoire d'installation de Java 2). En ce qui concerne Linux, la démarche est identique en tout point.

Une fois Java 2 et Java 3D correctement installés, il est nécessaire de mettre à jour la variable PATH de Windows (ou de Linux).

Cliquez avec le bouton droit sur Poste de travail, puis sélectionnez le menu Propriétés. La fenêtre Propriétés système apparaît.

Choisissez l'onglet Avancé puis cliquez sur le bouton Variables d'environnement.

Dans la liste déroulante intitulée Variables système, sélectionner Path puis cliquez sur le bouton Modifier.

Dans la zone de texte Valeur de la variable, rajouter au début le chemin complet vers l'exécutable java.exe que l'on vient juste d'installer en le faisant suivre d'un point-virgule.
Voici un exemple de ligne à rajouter dans le PATH :

C:\java\j2sdk1.4.2_06\jre\bin;

Cliquez sur le bouton OK des boites de dialogue restées ouvertes pour valider la modification (il n'est pas nécessaire de redémarrer le système pour que la modification soit prise en compte).

Importation des packages Java 2 de base permettant de construire les bases de notre application.

import java.applet.Applet;
import java.awt.*;

Importation des packages Java 3D permettant d'utiliser les fonctions 3D

import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.geometry.ColorCube;
import com.sun.j3d.utils.universe.*;
import javax.media.j3d.*;

Ensuite, nous passons à l'écriture du constructeur de notre classe ColorCube3D.

Création d'un Canvas3D
La classe Canvas3D dérive de la classe Canvas de l'Abstract Windowing Toolkit (AWT) de Java 2. Elle sert en fait à représenter des objets 3D dans une fenêtre à deux dimensions qui est celle affichée à l'écran. Le constructeur de la classe Canvas3D a besoin d'un objet qui fournit les caractéristiques de la destination graphique dans laquelle nous allons visualiser notre application, c'est-à-dire l'écran de notre ordinateur dans le cas présent. Cet objet est fourni par la classe utilitaire SimpleUniverse.

Canvas3D canvas3D = new Canvas3D(SimpleUniverse.getPreferredConfiguration());

Création d'un univers 3D permettant d'intégrer le canvas3D que nous venons de créer

SimpleUniverse simpleU = new SimpleUniverse(canvas3D)

Positionnement d'un point d'observation et du canvas 3D pour avoir une vue d'ensemble correcte de la scène 3D

simpleU.getViewingPlatform().setNominalViewingTransform()

Création de la scène 3D contenant tous les objets que l'on veut visualiser
C'est la méthode createSceneGraph() de notre classe ColorCube3D qui va créer tous les objets 3D. Il s'agit d'abord de créer un objet « maître » ou « parent » auquel nous allons rattacher le cube 3D. Cet objet est une instance de la classe BranchGroup.

BranchGroup parent = new BranchGroup()

Ensuite, nous allons lui ajouter le cube 3D en couleur. Java 3D fournit une classe prête à l'emploi permettant de créer des couleurs : ColorCube.

parent.addChild(new ColorCube(0.4));

L'argument 0.4 est un facteur d'échelle afin que le cube puisse être vu en entier dans la fenêtre de notre application. Nous avons volontairement occulté la partie de cet exemple permettant d'animer ce cube.
Vous vous reporterez aux chapitres Tranformations géométriques et Animation (en construction) pour plus de détails sur la manière de gérer les transformations et les animations.

Compilation de la scène
Une fois la scène créée par la méthode createSceneGraph(), il faut la compiler afin de la transformer en une série d'instructions très performantes qui seront envoyées au moteur de rendu de la carte graphique chargé de l'affichage.

scene.compile()

Ajouter la scène 3D à l'univers 3D
C'est la dernière étape de la création de notre application 3D

simpleU.addBranchGraph(scene);

Écriture de la méthode main()

public static void main(String[] args) {
  Frame frame = new MainFrame(new ColorCube3D(), 256, 256);
}

Le fichier ColorCube3D.java présente le code source complet de ce premier exemple :

// Étape 1 :
// Importation des packages Java 2
import java.applet.Applet;
import java.awt.*;

// Étape 2 :
// Importation des packages Java 3D
import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.geometry.ColorCube;
import com.sun.j3d.utils.universe.*;
import javax.media.j3d.*;

public class ColorCube3D extends Applet {

  public ColorCube3D() {
    this.setLayout(new BorderLayout());

    // Étape 3 :
    // Creation du Canvas 3D
    Canvas3D canvas3D = new Canvas3D(SimpleUniverse.getPreferredConfiguration());

    this.add(canvas3D, BorderLayout.CENTER);

    // Étape 4 :
    // Creation d'un objet SimpleUniverse
    SimpleUniverse simpleU = new SimpleUniverse(canvas3D);

    // Étape 5 :
    // Positionnement du point d'observation pour avoir une vue correcte
    // de la scene 3D
    simpleU.getViewingPlatform().setNominalViewingTransform();

    // Étape 6 :
    // Creation de la scene 3D qui contient tous les objets 3D que l'on
    // veut visualiser
    BranchGroup scene = createSceneGraph();

    // Étape 7 :
    // Compilation de la scene 3D
    scene.compile();

    // Étape 8:
    // Attachement de la scene 3D a l'objet SimpleUniverse
    simpleU.addBranchGraph(scene);
  }

  /**
   * Creation de la scene 3D qui contient tous les objets 3D
   * @return scene 3D
   */
  public BranchGroup createSceneGraph() {
    // Creation de l'objet parent qui contiendra tous les autres objets 3D
    BranchGroup parent = new BranchGroup();

    /************ Partie de code concernant l'animation du cube *************/
    /* Elle sera expliquee en details dans les chapitres relatifs aux
       transformations geometriques et aux animations */
    TransformGroup objSpin = new TransformGroup();
    objSpin.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
    Alpha rotationAlpha = new Alpha(-1, 4000);
    RotationInterpolator rotator = new RotationInterpolator(rotationAlpha, objSpin);
    BoundingSphere bounds = new BoundingSphere();
    rotator.setSchedulingBounds(bounds);
    objSpin.addChild(rotator);
    /*************** Fin de la partie relative a l'animation ****************/

    // Construction du cube couleur
    objSpin.addChild(new ColorCube(0.4));
    parent.addChild(objSpin);

    return parent;
  }

  /**
   * Étape 9 :
   * Methode main() nous permettant d'utiliser cette classe comme une applet
   * ou une application.
   * @param args
   */
  public static void main(String[] args) {
    Frame frame = new MainFrame(new ColorCube3D(), 256, 256);
  }
}

Avant de pouvoir exécuter ce programme, il faut le compiler.
Pour cela, cliquer sur le menu Démarrer puis sélectionner Programmes et Accessoires.
Sélectionner ensuite le menu Invite de commandes.

Dans la ligne de commandes, positionnez - vous là où se trouve le fichier ColorCube3D.java puis lancez la commande javac ColorCube3D.java. Un fichier ColorCube.class est alors automatiquement créé.

Pour exécuter le programme en tant qu'application indépendante, il suffit de lancer la commande : java ColorCube3D.

Pour exécuter le programme en tant qu'applet avec un navigateur web, il suffit de créer un fichier .html avec une balise APPLET comme suit :

<APPLET CODE="ColorCube3D.class" WIDTH=256 HEIGHT=256>
</APPLET>

Ouvrir ensuite le fichier ColorCube3D.html avec votre navigateur préféré et le cube en couleurs animé apparaîtra aussitôt :

Vous pouvez aussi exécuter l'application avec Java Web Start (cela évite d'installer Java 3D au préalable) en répondant sans crainte « oui » aux éventuels avertissements de sécurité : ColorCube3D.jnlp