Testez vos programmes OpenGL avec cet applet.

L'idée de base : vous programmez la partie centrale d'un programme OpenGL, c'est à dire le contenu de la fonction d'affichage et cet applet vous montre ce que ça fait sans aucune compilation. Vous pouvez modifier en temps réel votre programme pour en voir les effets.

Cet applet est programmé à l'aide de JoGL, une librairie java qui permet de faire de l'OpenGL pratiquement comme en C.

Vous devrez accepter le certificat si vous voulez lire et enregistrer des fichiers C à l'aide des menus de cet applet. Ce n'est pas nécessaire car vous pouvez copier-coller les textes très facilement.

Installation de JoGL : OpenGL pour Java

Premier essai avec cet applet

Copiez-collez les lignes suivantes dans la zone de texte à gauche :

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0f, 0.0f, -6.0f);
glRotatef(valeur0*5, 0.0f, 1.0f, 0.0f);
glRotatef(valeur1*5, 1.0f, 0.0f, 0.0f);
glRotatef(temps*15, 0.0f, 0.0f, 1.0f);

glBegin(GL_TRIANGLES);
glColor3f(1.0f, 0.5f, 0.0f); glVertex3f(0.0f, 1.0f, 0.0f);
glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 0.0f);
glColor3f(1.0f, 0.0f, 1.0f); glVertex3f(1.0f, -1.0f, 0.0f);
glEnd();

L'applet affiche un triangle coloré. Vous pouvez en temps réel éditer les paramètres des fonctions. Les curseurs en bas à droite permettent de modifier les variables valeur0 et valeur1 du programme. La variable temps peut évoluer, il suffit de cliquer sur les boutons.

Nb : sur Windows, il semble qu'il y ait un problème avec les fin de lignes. Le copier-coller met tout le texte sur une seule ligne. Je n'ai pas de solution pour l'instant parce que la plateforme java ne permet pas de savoir sur quel système on se trouve.

L'applet GLediteur

Si ça ne marche pas, ça vient très certainement soit d'une mauvaise installation de JOGL sur votre système, ou alors d'un problème de permissions pour cet applet : cet applet a besoin d'accéder à des fichiers binaires (jogl, gluegen) situés dans votre machine et tous les navigateurs ne l'acceptent pas.

Dans ce cas, il faut lancer à la main. Enregistrez cette page sous le nom GLediteur.htm, puis téléchargez cet applet sous le nom GLediteur.jar et ce fichier sous policy.applet et lancez-l'ensemble par cette commande :

Exemples de programmes OpenGL

Note importante : ces programmes laissent chacun OpenGL dans un état complexe, or l'applet n'est pas capable de réinitialiser OpenGL d'un programme à l'autre car il ne sait pas que vous voulez changer de programme. Ca signifie qu'on ne peut pas passer d'un programme à l'autre. Il faut recharger cette page à chaque fois pour redémarrer l'applet avant de passer à un autre programme ou alors réinitialiser ce que vous avez modifié.

Pyramide colorée construite à l'aide de triangles

//// initialisations OpenGL
// effacement écran
glClearColor(0.0f, 0.0f, 0.0f, 0.5f); // fond = noir
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

// matrice de projection sur écran
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(50.0, 1.0, 1.0, 50.0);

// transformation du modèle
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0f, 0.0f, -6.0f);
glRotatef((valeur0-50)*5, 0.0f, 1.0f, 0.0f);
glRotatef(-valeur1*-5, 1.0f, 0.0f, 0.0f);

// pyramide
glBegin(GL_TRIANGLES);
    glColor3f(1.0f, 0.0f, 0.0f); glVertex3f(0.0f, 1.0f, 0.0f);
    glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
    glColor3f(1.0f, 1.0f, 0.0f); glVertex3f(1.0f, -1.0f, 1.0f);

    glColor3f(1.0f, 0.0f, 0.0f); glVertex3f(0.0f, 1.0f, 0.0f);
    glColor3f(1.0f, 1.0f, 0.0f); glVertex3f(1.0f, -1.0f, 1.0f);
    glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(1.0f, -1.0f, -1.0f);

    glColor3f(1.0f, 0.0f, 0.0f); glVertex3f(0.0f, 1.0f, 0.0f);
    glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(1.0f, -1.0f, -1.0f);
    glColor3f(0.0f, 0.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);

    glColor3f(1.0f, 0.0f, 0.0f); glVertex3f(0.0f, 1.0f, 0.0f);
    glColor3f(0.0f, 0.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
    glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glEnd();

Faire pivoter la pyramide à l'aide des curseurs 0 et 1.

Scène complexe

//// initialisations OpenGL
// effacement écran
glClearColor(0.5f, 0.7f, 0.8f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

// matrice de projection sur écran
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(50.0, 1.0, 1.0, 60.0);

// pilotage de la caméra
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0,0,-5-valeur2/2);
glRotatef(valeur1*3.6, 1.0f, 0.0f, 0.0f);
glRotatef(valeur0*3.6, 0.0f, 1.0f, 0.0f);

// terrain
glPushMatrix();
glScalef(15, 0.5, 15);
glCallList(terrain);
glPopMatrix();

// maison
glPushMatrix();
glTranslatef(0,0,-4);
glCallList(maison);
glPopMatrix();

// arbres
glPushMatrix();
glTranslatef(-6,0,-4); glCallList(arbre);
glTranslatef(6,0,-5); glCallList(arbre);
glTranslatef(6,0,5); glCallList(arbre);
glTranslatef(4,0,-8); glCallList(arbre);
glTranslatef(-1,0,18); glCallList(arbre);
glTranslatef(-16,0,1); glCallList(arbre);
glPopMatrix();

// voiture
glTranslatef(0f, 0.0f, -4);
glRotatef(temps*36, 0.0f, 1.0f, 0.0f);
glTranslatef(4,0,0);
glRotatef(90, 0,1, 0);
glCallList(voitureR);

Faire pivoter la scène à l'aide des curseurs 0 et 1. Eloigner ou rapprocher la caméra avec le curseur 2. Faire bouger la voiture en appuyant sur start (pour faire varier le temps).

Théière glut colorée et éclairée

//// initialisations OpenGL
// effacement écran
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

// matrice de projection sur écran
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(50.0, 1.0, 1.0, 50.0);

// activer l'éclairage et configurer la lampe 0
glEnable(GL_LIGHTING);
glLight4f(GL_LIGHT0,GL_AMBIENT, 0.1f, 0.1f, 0.1f, 1.0f);
glLight4f(GL_LIGHT0,GL_DIFFUSE, 0.9f, 0.9f, 0.9f, 1.0f);
glEnable(GL_LIGHT0);

// matériau de la théière = couleur
glMaterial4f(GL_FRONT_AND_BACK,GL_AMBIENT, 0.5f, 0.2f, 0.2f, 1.0f);
glMaterial4f(GL_FRONT_AND_BACK,GL_DIFFUSE, 0.5f, 0.2f, 0.2f, 1.0f);
glMaterial4f(GL_FRONT_AND_BACK,GL_SPECULAR, 0.8f, 0.8f, 0.8f, 1.0f);
glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS, 128);

// transformation de la scène
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0,0,4, 0,0,0, 0,1,0);

// position de la théière
glPushMatrix();
glRotatef(valeur0*3.6, 0.0f, 1.0f, 0.0f);
glRotatef(valeur1*3.6, 1.0f, 0.0f, 0.0f);
glutSolidTeapot(1.0);
glPopMatrix();

// position de la lampe
glPushMatrix();
glRotatef(valeur2*3.6-45, 0.0f, 1.0f, 0.0f);
glRotatef(-valeur3*3.6, 1.0f, 0.0f, 0.0f);
glLight4f(GL_LIGHT0,GL_POSITION, 0.0f, 0.0f, 4.0f, 1.0f);
glPopMatrix();

Faire pivoter la théière à l'aide des curseurs 0 et 1. Faire pivoter l'éclairage à l'aide des curseurs 2 et 3. 

Théière glut texturée et éclairée

//// initialisations OpenGL
// effacement écran
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

// matrice de projection sur écran
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(50.0, 1.0, 1.0, 50.0);

// activer l'éclairage et configurer la lampe 0
glEnable(GL_LIGHTING);
glLight4f(GL_LIGHT0,GL_AMBIENT, 0.1f, 0.1f, 0.1f, 1.0f);
glLight4f(GL_LIGHT0,GL_DIFFUSE, 0.9f, 0.9f, 0.9f, 1.0f);
glEnable(GL_LIGHT0);

// matériau de la théière = texture prédéfinie de l'applet
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texfeuilles);

// transformation de la scène
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0,0,4, 0,0,0, 0,1,0);

// position de la théière
glPushMatrix();
glRotatef(valeur0*3.6, 0.0f, 1.0f, 0.0f);
glRotatef(valeur1*3.6, 1.0f, 0.0f, 0.0f);
glutSolidTeapot(1.0);
glPopMatrix();

// position de la lampe
glPushMatrix();
glRotatef(valeur2*3.6-45, 0.0f, 1.0f, 0.0f);
glRotatef(-valeur3*3.6, 1.0f, 0.0f, 0.0f);
glLight4f(GL_LIGHT0,GL_POSITION, 0.0f, 0.0f, 4.0f, 1.0f);
glPopMatrix();

Faire pivoter la théière à l'aide des curseurs 0 et 1. Faire pivoter l'éclairage à l'aide des curseurs 2 et 3. 

Terre et Lune

//// initialisations OpenGL
// effacement écran
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

// matrice de projection sur écran
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(50.0, 1.0, 0.1, 50.0);

// activer l'éclairage et configurer la lampe 0 très intense (cause textures sombres)
glEnable(GL_LIGHTING);
glLight4f(GL_LIGHT0,GL_AMBIENT, 0.1f, 0.1f, 0.1f, 1.0f);
glLight4f(GL_LIGHT0,GL_DIFFUSE, 1.5f, 1.5f, 1.5f, 1.0f);
glEnable(GL_LIGHT0);
glPushMatrix();
glRotatef(valeur3*3.6-45, 0.0f, 1.0f, 0.0f);
glLight4f(GL_LIGHT0,GL_POSITION, 0.0f, 0.0f, 1.0f, 0.0f);
glPopMatrix();

// matériaux = textures prédéfinies de l'applet
glEnable(GL_TEXTURE_2D);

// transformation de la scène
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0,0,-valeur2/10-2);
glRotatef(valeur1*3.6, 1.0f, 0.0f, 0.0f);
glRotatef(valeur0*3.6, 0.0f, 1.0f, 0.0f);

// dessin de la terre
glPushMatrix();
  // dessin de la lune
    glPushMatrix();
 glRotatef(temps*9, 0.0f, 1.0f, 0.0f); // un tour en 40 secondes
 glTranslatef(3,0,0);
    glBindTexture(GL_TEXTURE_2D, texlune); // appliquer cette texture au prochain objet
 glutSolidSphere(0.25, 24, 12);
  glPopMatrix();
glRotatef(temps*36, 0.0f, 1.0f, 0.0f); // un tour en 10 secondes
glBindTexture(GL_TEXTURE_2D, texterre); // appliquer cette texture au prochain objet
glutSolidSphere(1.0, 24, 12);
glPopMatrix();

Lancer l'animation en cliquant sur start. Contrôler la vue avec les curseurs 0, 1 et 2. Orientez la lumière avec le curseur 3.

Remarque : en réalité la Lune est très sombre et la Terre très lumineuse. Le sol de la Lune est à peu près aussi réfléchissant que du charbon -- c'est dire la puissance du Soleil. Le constater sur cette image prise par les astronautes d'Apollo 8.

Informations sur l'applet

Cet applet est capable d'interpréter une petite partie d'un programme OpenGL. Il évolue peu à peu, de nouvelles capacités sont ajoutées régulièrement.

Généralités

La fenêtre source ne peut recevoir que des lignes constituées d'un appel de fonction OpenGL. On ne peut pas définir de variable ni faire autre chose. La syntaxe générale des lignes est :

NOMFONCTION(PARAMETRES...); // commentaire

On est donc limité aux fonctions dont tous les paramètres sont fournis sous forme d'une lignes : par exemple glVertex3f. Il est impossible d'utiliser les fonctions du type glVertex3fv qui demandent un paramètre de type tableau créé et initialisé auparavant.

Fonctions OpenGL

Toutes les fonctions OpenGL nécessaires au cours sont opérationnelles, mais avec quelques différences avec le véritable OpenGL. Les fonctions telles que glLightfv et glMaterialfv qui n'existent qu'en version "paramètre tableau" n'ont pas pu être programmées telles quelles. A la place, il faut employer glLight4f et glMaterial4f qui n'existent pas dans le véritable OpenGL. Voir les exemples ci-dessus.

Au lieu de :

GLfloat position[4] = { 0.0f, 0.0f, 4.0f, 1.0f };
glLightfv(GL_LIGHT0,GL_POSITION, position);

il faut mettre :

glLight4f(GL_LIGHT0,GL_POSITION, 0.0f, 0.0f, 4.0f, 1.0f);

Le menu Fonctions donne la liste des fonctions connues. La notation nom/n signifie que la fonction nom prend n paramètres. Il faut consulter la référence OpenGL pour avoir le détail.

La fonction glutSolidSphere a été modifiée pour ajouter les coordonnées de texture à chaque vertex. Si vous l'utilisez dans un programme C, il vous faudra la récrire.

Paramètres des fonctions

On peut fournir une expression arithmétique simple : a+b*(c+(d+e)*f)... où les lettres sont des nombres ou des symboles déjà définis :

• temps : variable automatiquement incrémentée si le bouton go/stop est actif.
• valeur0...valeur3 : sont les valeurs des quatre curseurs.
• les symboles d'OpenGL, tels que GL_MODELVIEW, GL_TRIANGLES... La liste complète des symboles connus est dans le menu symboles.
• des noms de textures prédéfinies, telles que texfauve, texrouille, texsable, texparquet, texfeuilles, texbeton, texbriques, texterrain, texpierre, texterre, texlune. D'autres seront ajoutées par la suite selon les besoins. Il y aura un jour possibilité de charger quelques textures perso.
• des noms de listes d'affichage prédéfinies : oeil, camera, soleil, pyramide4, sphereR, sphereV, sphereB, voitureR, voitureV, voitureB, terrain, repere, grille, arbre, maison pour glCallList. Attention, ces différents objets ont des tailles et des orientations encore assez disparates. Une prochaine version les mettra tous d'accord.

On peut employer quelques fonctions mathématiques : sqrt, sin, cos, tan, asin, acos, atan.

Restent à faire

Un certain nombre de concepts ne sont pas programmés et ne peuvent pas être testés, mais sont prévus avant les cours concernés :

• La création de listes d'affichage n'est pas possible pour l'instant, mais risque sûrement d'être restreinte à un petit nombre de listes.
• On ne peut pas créer de nouvelles textures. Il est prévu de pouvoir charger des fichiers perso mais ce n'est pas une priorité.
• Les stencils ne sont pas manipulables.
• Les shaders ne peuvent pas être ajoutés.