Développement d'applications 3D avec JOGL et l'environnement de développement Eclipse

Laurent Bernabé

JOGL est un framework permettant de tirer parti de la bibliothèque 3D OpenGL par le biais du langage Java.

L'environnement de développement intégré Eclipse est souple dans le sens où il permet une très grande personnalisation tant au niveau des préférences qu'au niveau de la gestion des projets.

Fort de ces deux outils, je vais démontrer qu'on peut aisément réaliser un déploiement d'applications 3D en archives autoexécutables pour différents systèmes d'exploitation.

Commentez

- Titre : Développement d'applications 3D avec JOGL et l'environnement de développement Eclipse

- Auteur : Laurent Bernabé

- Parution : 18 décembre 2012

- Public visé :

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2012 Laurent Bernabé. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Introduction

- II. Prérequis

- III. Création des bibliothèques personnalisées JOGL

- III-A. Création de la bibliothèque JOGL_Core

- III-B. Création des bibliothèque s natives de JOGL

- IV. Le projet sphère tournante 3d

- IV-A. Création du projet

- IV-B. Ajouts des classes

- V. Exportation de l'application sur différents systèmes d'exploitation

- V-A. Modifier le classpath du projet : retirer la bibliothèque JOGL du système hôte et ajouter celle du système cible

- V-B. Exporter l'application en tant qu'archive autoexécutable

- VI. Remerciements

I - Introduction

Dans cet article, je vais présenter une méthode simple pour parvenir à développer une application 3D à l'aide de la bibliothèque OpenGL pour Java JOGL, et de l'Environnement de Développement Intégré Eclipse. Par contre cela ne représentera ni un cours sur la programmation OpenGL, ni un cours sur l'utilisation de JOGL 2. C'est juste pour montrer comment on peut facilement utiliser JOGL avec Eclipse.

Évidemment, l'application ne sera pas très volumineuse (ce sera juste une sphère qui tourne sur elle-même) : mais cela sera suffisant pour vous présenter ma méthode.

Nous verrons également comment exporter l'application en archives autoexécutables pour différents OS (et plusieurs architectures : 32 ou 64 bits).

Aperçu de l'application

(cliquez ici pour aggrandir l'image)

II - Prérequis

1. Tout d'abord, veuillez installer le JDK d'Oracle le plus à jour (version 7 à ce jour), correspondant à votre système d'exploitation : page de téléchargement d'Oracle.

2. Veuillez télécharger l'EDI Eclipse le plus à jour (Eclipse Juno à ce jour), correspondant à votre système d'exploitation : page de téléchargement d'Eclipse.

3. Veuillez, si ce n'est déjà fait, installer l'utilitaire 7 zip (si vous êtes sur Linux, il devrait déjà être présent dans votre gestionnaire de paquets).

4. Veuillez enfin télécharger et décompresser la bibliothèque JOGL, peu importe l'endroit, pourvu que vous la retrouviez ultérieurement : nous voulons les archives glugen-javadoc.7z, jogamp-all-platforms.7z, et jogl-javadoc.7z .

III - Création des bibliothèques personnalisées JOGL

Nous allons créer des bibliothèques personnalisées pour JOGL : il suffira alors de les intégrer à nos projets (ce que nous verrons ultérieurement dans cet article) pour développer avec JOGL. Il y aura un socle commun JOGL_CORE, et une bibliothèque par couple OS/architecture (JOGL_Win_32, par exemple).

III-A - Création de la bibliothèque JOGL_Core

Veuillez ouvrir le menu Windows->Preferences, et filtrer les préférences en commençant à taper user libraries dans le champ de recherche. Veuillez alors sélectionner ce menu.

Le filtrage des préférences

(cliquez ici pour aggrandir l'image)

Veuillez alors cliquer sur le bouton new pour créer une nouvelle bibliothèque personnalisée.

Le bouton New

(cliquez ici pour aggrandir l'image)

Veuillez alors saisir le nom de la nouvelle bibliothèque (jogl_core) et vérifier que la case à cocher System Library est décochée.

La case System Library

(cliquez ici pour aggrandir l'image)

Votre bibliothèque vient d'être ajoutée : mais elle est vide. Cliquez sur le bouton Add Jars (après vous être assuré que la bibliothèque est sélectionnée).

Le bouton Add Jars

(cliquez ici pour aggrandir l'image)

Veuillez, avec l'explorer qui vous est alors soumis, vous rendre dans le dossier de l'archive jogamp-all-platforms.7z décompressée précédemment. Veuillez entrer dans le sous-dossier jars, et sélectionner les deux fichiers suivants (avec la touche CTRL en même temps que le clic, au besoin) :

- jogl-all.jar ;

- gluegen-rt.jar.

Vous verrez donc que des « liens » ont été ajoutés sur vos jars. Pour chacun d'eux, on peut alors distinguer quatre nœuds enfants :

- le lien vers les sources du jar : il est possible de les télécharger sur la page de jogamp que je vous ai déjà donnée, mais je n'ai pas choisi de m'en préoccuper dans l'article. Cela dit, la procédure n'a rien de compliqué ;

- le lien vers la javadoc du jar ;

- le lien vers les fichiers natifs (codés en C/C++) du jar ;

- la définition des fichiers à exclure de la bibliothèque : nous n'aurons pas besoin de cette fonctionnalité.

Les nœuds des jars ajoutés.

(cliquez ici pour aggrandir l'image)

Ici, nous ne remplirons que le nœud javadoc des deux jars : en effet, même si la bibliothèque JOGL est basée sur l'utilisation de fichiers natifs, comme ils sont déjà fournis dans des jars on n'aura pas besoin de renseigner le nœud natives library. Il suffira donc d'ajouter des liens sur les différents jars contenant ces fameux fichiers. Ce que nous ferons ultérieurement dans cet article.

Renseigner le nœud javadoc permet notamment à Eclipse de bien nommer les arguments des méthodes de JOGL implémentées ou redéfinies. Par exemple avoir

draw(int widht, int height)

(la méthode draw est factice), au lieu de

draw(int arg0, int arg1)

Ce qui déjà nous facilite bien le travail : on n'est plus forcé d'aller regarder sur la documentation de JOGL pour savoir comment s'en servir.

Veuillez double-cliquer sur le nœud du jar glugen-rt. Veuillez alors sélectionner l'option Javadoc URL et cliquer sur le bouton Browse.

Le bouton Browse

(cliquez ici pour aggrandir l'image)

Veuillez alors sélectionner le chemin où vous avez décompressé la javadoc de gluegen, et sélectionner le sous-dossier javadoc. Le bouton Validate sert à certifier que le chemin est bien celui correspondant à une javadoc.

Validation du chemin de la javadoc.

(cliquez ici pour aggrandir l'image)

Veuillez faire de même avec le nœud javadoc du jar jogl-all : bien sûr en choisissant le sous-dossier javadoc de l'archive jogl-javadoc décompressée.

La bibliothèque jogl_core est maintenant définie : il ne manque plus que les différentes bibliothèques natives.

III-B - Création des bibliothèque s natives de JOGL

Nous allons d'abord créer la bibliothèque JOGL_natives_Windows_32. La procédure sera similaire pour toutes les bibliothèques.

1. Cliquez sur le bouton New, laissez le bouton System Library décoché, et nommez-la (jogl_natives_windows_32).

2. Sélectionnez cette nouvelle bibliothèque, cliquez sur Add Jars, et sélectionnez les jars (toujours dans le sous-dossier jars de l'archive jogamp-all-platforms décompressée) gluegen-rt-natives-windows-i586.jar et jogl-all-natives-windows-i586.jar.

Faites de même pour la bibliothèque jogl_natives_windows_64 : en choisissant les jars gluegen-rt-natives-windows-amd64.jar et jogl-all-natives-windows-amd64.jar.

Faites de même pour la bibliothèque jogl_natives_linux_32 : en choisissant les jars gluegen-rt-natives-linux-i586.jar et jogl-all-natives-linux-i586.jar.

Faites de même pour la bibliothèque jogl_natives_linux_64 : en choisissant les jars gluegen-rt-natives-linux-amd64.jar et jogl-all-natives-linux-amd64.jar.

Enfin, pour jogl_natives_mac_osx : choisissez les archives gluengen-rt-macosx-uniersal.jar et jogl-all-natives-macosx-universal.jar.

Veuillez enfin valider les préférences afin de ne pas perdre votre long travail.

IV - Le projet sphère tournante 3d

IV-A - Création du projet

Veuillez créer un nouveau projet Java. (Soit File->New->Java project si disponible. Ou sinon File->New Project puis dans la nouvelle fenêtre, choisir Java->Java project.) Veuillez ne pas valider tout de suite la création du projet.

Veuillez cliquer sur l'onglet Libraries puis sur le bouton Add Libraries.

L'onglet User Libraries et le bouton Add Library

(cliquez ici pour aggrandir l'image)

Veuillez choisir l'option User Libraries (et cliquer sur le bouton Next). Veuillez alors choisir la bibliothèque jogl_core ainsi que la bibliothèque correspondant au couple votre os/votre architecture (par exemple, jogl_natives_windows_32 pour un Windows d'architecture 32 bits) : n'oubliez pas de cliquer sur Finish.

Choix dess personnalisées pour le projet

(cliquez ici pour aggrandir l'image)

IV-B - Ajouts des classes

Veuillez copier les trois sources suivantes dans votre projet. Pour chaque source :

1. Copiez-la dans le presse-papiers ;

2. Sélectionnez le nœud src du projet dans la vue Project Explorer (au besoin, Window->Show View->Project Explorer pour la rendre visible) ;

3. Collez tout simplement : si le paquetage n'est pas encore créé, Eclipse le fera pour nous. Sinon, le fichier nouvellement créé sera placé dans le bon paquetage !

AppLauncher

1. package com.gmail.bernabe.laurent.jogl.spinning_sphere;

3. public class AppLauncher {

5. public static void main(String[] args) {

6. new MainFrame().setVisible(true);

7. }

9. }

MainFrame

1. package com.gmail.bernabe.laurent.jogl.spinning_sphere;

3. import java.awt.event.WindowAdapter;

4. import java.awt.event.WindowEvent;

6. import javax.media.opengl.GLCapabilities;

7. import javax.media.opengl.GLProfile;

8. import javax.media.opengl.awt.GLCanvas;

9. import javax.swing.JFrame;

11. import com.jogamp.opengl.util.FPSAnimator;

13. public class MainFrame extends JFrame {

15. public MainFrame(){

16. setTitle("Lit Sphere Demo, with JOGL");

17. setSize(640, 480);

19. GLCapabilities glCapabilities = new GLCapabilities(GLProfile.getDefault());

20. GLCanvas glCanvas = new GLCanvas(glCapabilities);

21. MyGLEventListener glListener = new MyGLEventListener();

22. glCanvas.addGLEventListener(glListener);

23. add(glCanvas);

25. final FPSAnimator animator = new FPSAnimator(glCanvas, 60);

27. addWindowListener(new WindowAdapter() {

29. @Override

30. public void windowClosing(WindowEvent e) {

31. animator.stop();

32. System.exit(0);

33. }

35. });

37. animator.start();

38. }

40. private static final long serialVersionUID = -1227038124975588633L;

42. }

MyGLEventListener

1. package com.gmail.bernabe.laurent.jogl.spinning_sphere;

3. import javax.media.opengl.GL2;

4. import javax.media.opengl.GLAutoDrawable;

5. import javax.media.opengl.GLEventListener;

6. import javax.media.opengl.glu.GLU;

8. import com.jogamp.opengl.util.gl2.GLUT;

10. public class MyGLEventListener implements GLEventListener {

12. @Override

13. public void init(GLAutoDrawable drawable) {

14. GL2 gl = drawable.getGL().getGL2();

16. gl.glClearColor(0.8f, 0.5f, 0.0f, 1.0f);

18. gl.glEnable(GL2.GL_DEPTH_TEST);

19. gl.glClearDepth(1.0f);

21. gl.glShadeModel(GL2.GL_SMOOTH);

22. gl.glEnable(GL2.GL_LIGHTING);

24. gl.glEnable(GL2.GL_LIGHT0);

25. gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_AMBIENT, light_0_ambient, 0);

26. gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, light_0_diffuse, 0);

27. gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_SPECULAR, light_0_specular, 0);

28. gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_POSITION, light_0_position, 0);

30. gl.glEnable(GL2.GL_COLOR_MATERIAL);

31. gl.glColorMaterial(GL2.GL_FRONT_AND_BACK, GL2.GL_AMBIENT_AND_DIFFUSE);

32. gl.glMateriali(GL2.GL_FRONT_AND_BACK, GL2.GL_SHININESS, 90);

33. gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_SPECULAR, material_specular, 0);

34. }

36. @Override

37. public void dispose(GLAutoDrawable drawable) {

38. // TODO Auto-generated method stub

40. }

42. @Override

43. public void display(GLAutoDrawable drawable) {

44. GL2 gl = drawable.getGL().getGL2();

45. gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);

46. gl.glLoadIdentity();

48. glu.gluLookAt(

49. camera[0], camera[1], camera[2],

50. 0.0f, 0.0f, 0.0f,

51. 0.0f, 1.0f, 0.0f

52. );

54. gl.glRotatef(angle, 0f, 1f, 0f);

56. gl.glColor3f(1.0f, 0.0f, 0.0f);

57. glut.glutSolidSphere(1.0f, 20, 20);

59. angle += 0.1f;

60. angle %= 360f;

61. }

63. @Override

64. public void reshape(GLAutoDrawable drawable, int x, int y, int width,

65. int height) {

66. GL2 gl = drawable.getGL().getGL2();

67. gl.glViewport(x, y, width, height);

69. gl.glMatrixMode(GL2.GL_PROJECTION);

70. gl.glLoadIdentity();

71. glu.gluPerspective(60.0f, (float) width/height, 0.1f, 10.0f);

73. gl.glMatrixMode(GL2.GL_MODELVIEW);

74. }

76. private GLU glu = new GLU();

77. private GLUT glut = new GLUT();

79. private float camera [] = {0f, 0f, 5f};

81. private float [] light_0_ambient = {0.01f, 0.01f, 0.01f, 0.01f};

82. private float [] light_0_diffuse = {1.0f, 1.0f, 1.0f, 1.0f};

83. private float [] light_0_specular = {1.0f,1.0f, 1.0f, 1.0f};

84. private float [] light_0_position = {100f, 0f, 10f, 1f};

86. private float [] material_specular = {1.0f, 1.0f, 1.0f, 1.0f};

88. private float angle = 0f;

89. }

Si vous lancez le projet (Run->Run As...-> Java Application et choix de la classe AppLauncher) : vous devriez voir apparaître une sphère rouge tournant sur elle-même.

L'application sphère tournante.

(cliquez ici pour aggrandir l'image)

V - Exportation de l'application sur différents systèmes d'exploitation

L'exportation de l'application sur différents systèmes d'exploitation/architectures devient alors très simple. Voici la procédure, chaque étape sera détaillée plus loin :

1. Si on ne désire pas exporter pour le système hôte, il faut retirer la bibliothèque JOGL personnalisée qui lui correspond du projet. Et conserver la bibliothèque jogl_core ;

2. Ajouter la bibliothèque du système pour lequel on désire exporter. (De même que pour l'étape 1, désirable uniquement si on ne veut pas exporter pour le système hôte.) ;

3. Exporter l'application en tant qu'archive autoexécutable.

V-A - Modifier le classpath du projet : retirer la bibliothèque JOGL du système hôte et ajouter celle du système cible

Tout d'abord, il faut que vous sachiez repérer quelles bibliothèques sont intégrées au classpath de votre projet, et ce, directement depuis le Project Explorer. Ce sont ces nœuds dont l'icône est une pile de livres, sauf un : celui correspondant au JDK Java utilisé.

Classpath du projet

(cliquez ici pour aggrandir l'image)

Sachez tout de même que si nous nous contentons ici d'ajouter des bibliothèques personnalisées, il est également possible d'importer un jar d'une bibliothèque existante dans le projet, puis de l'ajouter au classpath. Ce n'était pas possible pour JOGL, à cause des bibliothèques natives, mais de toute façon, cela dépasse le cadre de l'article.

La capture précédente montre que JoglCore et JoglLinux64 font partie du classpath. JRE System Library est bien sûr un artifice d'Eclipse, nous permettant d'un coup d'œil de voir quel est le JDK utilisé.

On veut donc remplacer JoglLinux64 par, mettons, JoglWindows32.

Veuillez, dans le project explorer, sélectionner le nœud racine du projet, et avec un clic droit, accéder au menu Build Path → Configure Build Path. Dans la fenêtre qui apparaît, cliquez sur l'onglet Libraries.

Configuration du classpath du projet

(cliquez ici pour aggrandir l'image)

Pour retirer la bibliothèque « inadaptée » pour l'exportation, rien de plus simple. Il suffit de la sélectionner et de cliquer sur le bouton Remove. Ne vous inquiétez pas, elle sera juste supprimée du projet, pas de votre workspace Eclipse.

Le bouton Remove

(cliquez ici pour aggrandir l'image)

Pour ajouter la bibliothèque adéquate, la procédure ressemble beaucoup à celle que nous avons utilisée pour ajouter les bibliothèques lors de la création du projet.

1. Veuillez cliquer sur le bouton Add Library.

2. Veuillez choisir l'option User Libraries.

3. Veuillez cocher sur la bibliothèque à ajouter et valider : si vous avez un message d'erreur, normalement, c'est parce que la bibliothèque fait déjà partie de votre classpath.

Bouton Add Library

(cliquez ici pour aggrandir l'image)

Enfin, veuillez ne pas oublier de valider la fenêtre de configuration.

V-B - Exporter l'application en tant qu'archive autoexécutable

L'étape précédente, où nous n'avons retenu que la bibliothèque du système cible et la bibliothèque Jogl_core, est ultra importante : de cette manière Eclipse n'exportera dans le jar final que les bibliothèques natives du système cible. (On évite d'ajouter les bibliothèques natives de JOGL correspondant au système hôte, qui n'est pas celui pour lequel nos voulons déployer l'application.) Mais évidemment, pour tester à nouveau l'application, il faudra faire la manipulation inverse : enlever la bibliothèque JOGL du système cible et rétablir la bibliothèque JOGL du système hôte. Néanmoins, cette manipulation n'a rien de fastidieux, comme vous avez pu le remarquer.

Sélectionnez votre projet, et lancez le menu contextuel (par clic droit dessus) Export…
Dans la nouvelle fenêtre qui apparaît, sélectionnez l'option Java-> Runnable Jar File et cliquez sur Next.

L'option Launch Configuration correspond à la classe qui contient la méthode void main(String args[]) que l'on voudra utiliser comme point d'entrée (en effet, il peut y avoir plusieurs classes avec une telle méthode au sein du projet). Choisissez la classe AppLauncher du projet SpinningSphere3D (logique).
Inutile de vous précisez que l'option Export destination, avec le bouton Browse à sa droite, permet de sélectionnez le nom et l'emplacement du fichier à créer. Eclipse acceptant dans la boîte de dialogue les formats jar et zip : n'oubliez pas de préciser l'extension jar.
Enfin l'option Library Handing permet de choisir comment la bibliothèque sera intégrée au jar : choisissez « Extract required libraries into jar » afin que les différents fichiers de la bibliothèque JOGL fassent directement partie intégrante de l'archive générée.

Décochez si ce n'est déjà fait, l'option Save as ANT Script.

Cliquez sur Finish : le message d'avertissement qui apparaît veut vous sensibiliser aux problèmes éventuels de licences. Mais comme JOGL est Open Source, je pense que si votre projet n'est pas commercial, il n'y a pas de problème.
Vous pouvez répéter l'opération (changer le classpath puis exporter en jar autoexécutable) pour les différents systèmes d'exploitation et architectures voulus : cela ne devrait plus représenter trop de difficultés (cliquez donc sur OK si tout est bon pour vous, dans le cas contraire, c'est peut-être à vos risques et périls).

Voilà, c'est tout pour cet article.

VI - Remerciements

Je tiens à remercier les responsables du site Developpez.com, me permettant de publier cet article. Je voudrais remercier les modérateurs et responsables mlny84, _max_, littlewhite, keulkeul, gueritarish.

Je voudrais remercier djibril pour les différents kits qu'il développe ainsi que pour sa réactivité, facilitant notamment la rédaction d'articles sur les systèmes Linux.

Je voudrais remercier claudeLELOUP pour sa relecture orthographique.

Enfin je voudrais remercier tous ceux qui auront eu le courage de lire mon article.

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article