Intégration de la librairie jogl dans eclipse

Dernière mise à jour le par yoann090 .

Intégration de la librairie JOGL dans l’EDI Eclipse

Prérequis

  • Disposer d’une JRE Java (de préférence, la version 6 ou postérieure) installée
  • Disposer de l’EDI Eclipse installée
  • Disposer de l’archiveur 7Zip installé
  • Connaître la programmation d’interfaces graphiques en Java par la librairie standard AWT (il n’y aura ici pas de grande différence par rapport à l’utilisation de SWING).

Ce que montre ce tutoriel

  • Comment programmer avec JOGL dans Eclipse
  • Un exemple simple d’utilisation

Ce que ne montre pas ce tutoriel (entre autres)

  • Comment se servir d’Eclipse, même si je tente de bien décrire les différentes commandes utilisées
  • L’apprentissage d’OpenGL (mais cela serait une bonne idée , bien que je n’en connaisse que les rudiments, c’est-à-dire vous ne pourrez pas apprendre les textures avec moi)
  • La création de Jars auto-éxécutables utilisant JOGL

Télécharger JOGL

Pour cela, se rendre sur le site officiel, notamment :

http://jogamp.org/deployment/jogamp-current/archive/

(Figure 1)

Allez dans le dossier jogamp-<votre_systeme>-<votre_architecture> (Figure 2) : sachant que si vous n’êtes pas en mesure de déterminer l’architecture de votre ordinateur, vous avez plutôt intérêt à opter pour du i586. En effet, les architectures i586 étant plus anciennes que les architectures amd64, elles n’en sont pas moins compatibles avec ces machines.

Téléchargez alors les archives gluegen-<votre_systeme>-<votre_architecture>.7z et jogl-<votre_systeme>-<votre_architecture>.7z : décompressez-les là où vous pourrez vous en souvenir.

Créer la librairie JOGL dans Eclipse

Lancez le menu Windows->Preferences. Commencez à taper « User Libraries » dans le champ de texte destiné à filtrer la pléiade de menus disponibles, jusqu'à ce qu’il n’en reste qu’un seul. Choisissez-le alors. (Figure 3)

Créez une nouvelle librairie (bouton NEW) et nommez-la : mais surtout veillez à ce que le bouton « System library » ne soit pas coché. (Figure 4)

Votre nouvelle librairie apparaît donc, mais est encore vierge. (Figure 5)

Cliquez sur « Add Jars », alors :

  • Dans le dossier gluegen décompressé, allez dans le sous-dossier jars, et sélectionnez l’archive gluegen-rt.jar
  • Dans le dossier jogl décompressé, allez dans le sous-dossier jars, et sélectionnez l’archive jogl.all.jar

Les jars apparaissent alors dans la nouvelle librairie. (Figure 6)

Créer le projet exemple

Créez un nouveau projet Java : File->New->Java Project. Il suffit alors de nommer le projet et de valider.

Ouvrez la vue « Package Explorer » si ce n’est déjà fait (Windows->Show View->Package Explorer). Vous pouvez alors apercevoir votre projet, avec des informations sur la JRE Java utilisée (JRE System Library). (Figure 7)

Sélectionnez le nœud « src » du projet, et créez un package à l’aide de la commande File->New->Package : nommez-le com.javafr.jogl_example. (Figures 8 et 9)

Nous allons y créer une nouvelle classe. Pour cela, sélectionnez le package et lancez la commande File->New class : on peut vérifier que le package choisi est le bon, ou le modifier. Ici en l’occurrence, c’est déjà le bon, car on l’a selectionné auparavant. Nommez la classe JOGL_Example, laissez-la en statut « public », et ne cochez rien d’autre que l’option « Inherited methods », avant de valider. (Figure 10)

Du code est alors généré pour nous. Remplacez-en le contenu par le contenu suivant :

package com.javafr.jogl_example; 

import java.awt.Frame; 
import java.awt.event.WindowAdapter; 
import java.awt.event.WindowEvent; 
import javax.media.opengl.awt.GLCanvas; 
import com.jogamp.opengl.util.FPSAnimator; 

public class JOGL_Example extends Frame 


{ 


    public JOGL_Example(){ 


        /* 


          Attention, il semblerait qu'en dessous d'une certaine résolution (constaté sous XUbuntu 11.10), 


          l'animation ne fonctionne plus. (On le voit bien d'ailleurs aussitot 


          que l'on passe en "plein ecran" => l'animation fonctionne alors a nouveau).
  • /




        setSize(300,300); 


        setTitle("Jogl example"); 


        setLocationRelativeTo(null); // centrer la fenetre 


        GLCanvas glCanvas = new GLCanvas(); 


        // definit quelle instance de classe donnera les "commandes OpenGL" 


        glCanvas.addGLEventListener(new TheGLEventListener()); 


        // surtout ne pas oublier d'ajouter le canvas !!! 


        add(glCanvas); 


        /*
  • Il faut animer le canvas : pour passer d'une image à l'autre,
  • on delegue cela a un Animator (sans FPS fixe) ou un FPSAnimator (avec FPS fixe : ici 35)
  • /



        final FPSAnimator animator = new FPSAnimator(glCanvas, 35); 


        // Il faudra penser a arreter l'animateur !!! 

        addWindowListener(new WindowAdapter() { 


            @Override 


            public void windowClosing(WindowEvent e) { 


                animator.stop(); 

                System.exit(0); 

            } 

        });    

        // Surtout ne pas oublier de demarrer l'animateur !!! 

        animator.start(); 

    }   

    public static void main(String * args) { 

        new JOGL_Example().setVisible(true); 

    } 

    private static final long serialVersionUID = 1L; 

}

Sélectionnez le même package et créez de la même manière (File->New Class, avec les mêmes options) une nouvelle classe GLCube. Remplacez-en le code :

package com.javafr.jogl_example; 


import javax.media.opengl.GL2; 

public class GLCube { 

    public static void draw(GL2 gl){ 


        final float DEMI_TAILLE_CUBE = 0.5f;

        // On s'apprete a dessiner des quadrilateres 

        // Chaque groupe de 4 vertex definit 1 quadrilatere 

        gl.glBegin(GL2.GL_QUADS); 

        // les prochains vertex seront bleu 

        gl.glColor3f(0f, 0f, 1f); 

        // le quadrilatere de devant 

        gl.glVertex3f(-DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE); 

        gl.glVertex3f(+DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE); 

        gl.glVertex3f(+DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE); 

        gl.glVertex3f(-DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE); 

        // les prochains vertex seront verts 

        gl.glColor3f(0f, 1f, 0f); 

        // le quadrilatere de derriere 

        gl.glVertex3f(-DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE); 
      
        gl.glVertex3f(+DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE); 

        gl.glVertex3f(+DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE); 

        gl.glVertex3f(-DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE); 

        // les prochains vertex seront rouges 

        gl.glColor3f(1f, 0f, 0f); 

        // le quadrilatere de gauche 

        gl.glVertex3f(-DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE); 

        gl.glVertex3f(-DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE); 

        gl.glVertex3f(-DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE); 

        gl.glVertex3f(-DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE); 

        // les prochains vertex seront oranges 

        gl.glColor3f(1f, 0.5f, 0f); 

        // le quadrilatere de droite 

        gl.glVertex3f(+DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE); 

        gl.glVertex3f(+DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE); 

        gl.glVertex3f(+DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE); 

        gl.glVertex3f(+DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE); 

        // les prochains vertex seront blancs 

        gl.glColor3f(1f, 1f, 1f); 

        // le quadrilatere du haut 

        gl.glVertex3f(-DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE); 

        gl.glVertex3f(-DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE); 

        gl.glVertex3f(+DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE); 

        gl.glVertex3f(+DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE); 

        
        // les prochains vertex seront jaunes 

        gl.glColor3f(1f, 1f, 0f); 

        // le quadrilatere de bas 

        gl.glVertex3f(-DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE); 

        gl.glVertex3f(-DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE); 

        gl.glVertex3f(+DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE); 

        gl.glVertex3f(+DEMI_TAILLE_CUBE, -DEMI_TAILLE_CUBE, +DEMI_TAILLE_CUBE); 

        // On a fini 

        gl.glEnd(); 

    } 

}

De même, créer la dernière classe TheGLEventListener et remplacez le code par :

package com.javafr.jogl_example; 

import javax.media.opengl.GL2; 
import javax.media.opengl.GLAutoDrawable; 
import javax.media.opengl.GLEventListener; 
import javax.media.opengl.glu.GLU; 

public class TheGLEventListener implements GLEventListener { 

    // Le "paint(Graphics)" d'OpenGL 

    @Override 

    public void display(GLAutoDrawable drawable) { 

        // Nous, on va travailler en OpenGL 2 

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

        // Efface la memoire des couleurs, et la memoire des profondeurs 

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

        // reinitialise tous les calculs de coordonnes de tous les objets (dont la camera) 

        gl.glLoadIdentity(); 

        // Fixe la camera en z = 5, regarde (0,0,0) et a pour 

        // "vecteur haut" (l'axe y) l'axe (0,1,0), donc a le veritable axe y du repere 

        glu.gluLookAt( 

                0f, 0f, 5f, 

                0f, 0f, 0f, 

                0f, 1f, 0f 

        ); 

        // Tourne de la valeur courante d'angle 

        gl.glRotatef(currentAngle, 0f, 1f, 0f); 

        GLCube.draw(gl); 

        // Comme on a appele glLoadIdentity pour reinitialiser calculs, il faut penser 

        // a mettre l'angle a jour ^^ 

        currentAngle += 0.4f; 

    } 

    // le liberateur de ressources 

    @Override 

    public void dispose(GLAutoDrawable drawable) { 

        // TODO Auto-generated method stub 
        
    } 

    // initialiseur 

    @Override 

    public void init(GLAutoDrawable drawable) { 

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

        // Autorise les utilisations de profondeurs 

        gl.glEnable(GL2.GL_DEPTH_TEST); 

    } 

    // le redimensionneur d'image OpenGL (est appele a chaque redimensionnement du composant OpenGL) 

    @Override 

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

            int height) { 

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

        // On relie la zone du canvas a la "zone de travail d'OpenGL" 

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

        // On passe en mode : definition de la projection 

        gl.glMatrixMode(GL2.GL_PROJECTION); 

        // Surtout, reinitialiser calculs pour ce mode 

        // sinon les resultats seront cumules avec les precedents calculs 

        gl.glLoadIdentity(); 

        // Ici je choisis de definir une projection perspective (et non orthogonale) 

        // pour etre plus realiste 

        // demi-angle de vision en hauteur = 60 degres 

        // les objets situes ENTIEREMENT entre z = zCamera + 0.1 et zCamera + 10 seront visibles 

        // les autres seront tout simplement ignores 

        glu.gluPerspective(60f, (float) width/height, 0.1f, 10f); 

        // Surtout repasser en mode definition du dessin 

        // pour les prochains appels a la methode display() 

        gl.glMatrixMode(GL2.GL_MODELVIEW); 

    } 

    private GLU glu = new GLU(); 

    private float currentAngle; 

}

Ne vous préoccupez pas des erreurs qui apparaissent.

Utiliser la librairie dans le projet

Eclipse nous signale de nombreuses erreurs : les projets et fichiers concernés sont signalés d’une croix blanche sur fond rouge (en guise d’icône) dans le Package Explorer. On peut aussi les voir dans la vue Problems (Windows->Show View au besoin). (Figure 11)

En fait, elles disparaîtront dès que nous aurons paramétré le projet pour qu’il utilise la librairie JOGL. Sélectionnez le projet et lancez le menu File->Properties. Sélectionnez alors le menu « Java Build Path » (filtrer au besoin en tapant « Java Build Path » dans le champ texte).

On remarque alors, dans l’onglet Libraries, que seule la librairie standard est utilisée. (Figure 12) Cliquez sur « Add Library… » et sélectionnez l’option « User Libraries ». (Figure 13) Notre nouvelle librairie peut alors être séléctionnée, juste en cochant dessus et en validant la fenêtre. (Figures 14 et 15)

Validez les propriétés : les erreurs disparaissent alors et la nouvelle librairie fait partie intégrante du projet. (Figure 16)

Enfin, pour éxécuter le projet, lancez le menu Run->Run As->Java Application : choississez la classe JOGL_Example comme classe principale. (Figure 17) Un cube sur fond noir se met alors à tourner. (Figure 18)

Ce tutoriel est fini, j’espère avoir pu vous aider à configurer Eclipse pour JOGL. A l’heure où j’ai écrit ce tutoriel, la release candidate 6 de JOGL était encore en préparation, mais il ne devrait pas être difficile d’apdapter alors les instructions du tutoriel.

==Figures illustratives==

Figure

Figure

Figure 3

Figure

Figure 5

Figure

Figure

Figure

Figure

Figure

Figure

Figure

Figure

Figure

Figure

Figure

Figure

Figure

Adresse d'origine

Ce document intitulé « Intégration de la librairie jogl dans eclipse » issu de CodeS SourceS (codes-sources.commentcamarche.net) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.
JBI en theorie et pratique
Utilisation des expressions régulières en Java
Rejoignez-nous