Ce tutorial est basé sur celui écrit par Hideya Kawahara.

But: Créer une manipulation simple, et agissant avec l'utilisateur, dans un environnement en 3D, avec la librairie lg3d.
Requis: Ce tutoriel est construit par dessus le Tutoriel 1.
Pour utiliser ce tutorial, vous aurez besoin d'une installation pleinement fonctionnelle du projet Looking Glass. La version stable est celle que nous vous conseillons. Celle-ci se situe sur le site lg3d-core. Suivez également "Comment installer le projet Looking Glass (Getting started with Project Looking Glass)" pour les instructions d'installation.
Note: Vous n'avez pas besoin d'éxecuter la version lg3d-session.
De plus, vous aurez besoin d'installer le kit de développement Java 1.5. Vous pouvez vous le procurer sur le site officiel des développeurs en Java.
Étape:
  1. Initialiser l'application 3D
  2. Faire tourner la boite
  3. Permettre à l'application graphique d'être manipulée
  4. Définir le curseur de l'application
  5. Ajouter des évènements
  6. Ajouter une interaction avec l'utilisateur
  7. Initialisez le conteneur
  8. Compiler le code
  9. Lancer l'application
Étape 1: Initialiser l'application 3D
  Suivez les étapes de 1 à 3 dans le Tutorial 1 pour initialiser l'application, et créer une boite. Vous remarquerez que le jeu de lumière sur la boite, en changeant la valeur alpha dans le constructeur de SimpleAppearance.
    Frame3D frame3d = new Frame3D();
    SimpleAppearance app = new SimpleAppearance(0.6f, 0.8f, 0.6f, 0.7f);
    Box box = new Box(0.05f, 0.04f, 0.03f, Primitive.GENERATE_NORMALS | Primitive.GEOMETRY_NOT_SHARED, app);
    Component3D comp = new Component3D();
    comp.addChild(box);
Étape 2: Faire tourner la boite
Pour vérifier qu'il s'agit bien d'une boîte, nous pouvons la retourner et la voir en 3D.
La classe Component3D fournie des méthodes pour permettre cela. Premièrement, nous spécifions l'axe autour que sera utilisé par le composant, en utilisant la classe setRotationAxis.
    comp.setRotationAxis(1.0f, 0.5f, 0.0f);
Cela spécifie que la rotation se fera autour de la ligne passant par l'axe X à 1, et l'axe Y à 0.5.
Maintenant nous pouvons définir l'angle de rotation, en utilisant la classe setRotationAngle. La librairie utilise des radians, mais les degrés sont plus souvent utilisé, donc nous utiliserons la classe Math.toRadians() pour simplier.
    comp.setRotationAngle((float)Math.toRadians(60));
Remarquez que de la lumière aparait à la surface. Il s'agit de la classe SceneManager, qui en est responble. Si vous voulez, il est possible d'écrite un sceneManager qui change la lumière en fonction de l'heure de la journée, ou le taux d'utilisation des ressources de la machine.
Étape 3: Permettre à l'application graphique d'être manipulée
Une des fonctionnalités principales qui devraient être fournie par la plupart des applications est d'être déplaçable sur le bureau. Pour faciliter cela, une classe aux actions prédéfinies, ComponentMover a été implémentée.
Il implémente des "mouse event listeners" et des opérateurs de translation.
    new ComponentMover(comp);
Étape 4: Définir le curseur de l'application
Maintenant que l'application fonctionne, nous devons définir le curseur de la souris pour indiquer que le composant peut être déplacé.
Pour y parvenir, nous utilisons la classe prédéfinie Cursor3D et de sa méthode setCursor() afin d'associer le curseur au composant.
    comp.setCursor(Cursor3D.MOVE_CURSOR);
Étape 5: Ajouter des évènements
Des indicateurs visuels sont fournis afin d'indiquer q'une action peut être effectuée sur un objet. Le plus souvent, un bouton change d'aparence quand la souris l'approche pour indiquer qu'il peut être solicité. Les libraires de Looking Glass fournissent les premiers éléments pour implémenter une intéraction avec l'utilisateur.
Les deux concepts clés sont les "event adapter"s et les "action"s. Un adaptateur est un "listener" qui écoute des évènements spécifiques appel ensuite la méthode qui convient. Les listener utilisent l'interface Action Une "action" est une classe qui implémente au moins une sous-interface de l'interface Action. Il accepte les évènements et leur applique les méthodes prédéfinies.
Cet example utilise un MouseEnteredEventAdapter qui écoute les évènements d'entrée et de sortie des évènements, et appel la méthode performAction(boolean). La classe ScaleAction à son tours implémente l'interface ActionBoolean et la méthode performAction(boolean), qui est utilisée pour recevoir l'évènement. Il aligne le composant spécifié en fonction du facteur de son argument de type float. La durée de l'animation est spécifiée par le troisième argument, en millisecondes.
    new MouseEnteredEventAdapter(comp, new ScaleAction(comp, 1.2f, 500));
Étape 6: Ajouter des interactions avec l'utilisateur
Une autre utilisation de applications bureautiques est que l'application soit amené vers l'utilisateur quand on clique sur son icône. Pour présenter l'intéraction avec l'utilisateur, nous allons implémenter cette fonctionnalité dans notre application.
Nous aurons besoin de deux choses. Premièrement, un "listener" pour écouter les évènements générés par la souris. Ensuite, pour lancer un évènement au "SceneManager" en demandant que l'application soit amenée au premier plan.
Pour réaliser la première étape, la classe MouseClickedEventAdapter a besoin d'être créé pour écoute sur le composant. Le "MouseClickedEventAdapter" déclanche l'évènement Frame3DToFrontEvent (via le GenericEventPostAction) avec le Frame3D qui a été cliqué. Sachant que le "SceneManager" implémente cet évènement, la "Frame" devrait être amenée au premier plan.
    new MouseClickedEventAdapter(comp, new GenericEventPostAction(Frame3DToFrontEvent.class,frame3d));
Étape 7: Initialiser le conteneur
Finallement, nous pouvons ajouter le "Frame" au conteneur et l'initialiser afin de le rendre visible, comme décrit dans le Tutorial 1 étape 4. Remarque: Quand la boite est tournée, et redimmensionnée, une taille conseillée assé large (hint size) est pour éviter les conflits entre les applications 3D.
    frame3d.addChild(comp);
    frame3d.setSize(0.06f, 0.06f, 0.06f);
    frame3d.setCapabilities();
    frame3d.setActive(true);
    frame3d.setVisible(true);
Étape 8: Compiler le code
Nous avons fini d'écrire le code. La version complète inclue les imports des librairies, et différents constructeurs, et méthodes main. Téléchargez Tutorial2.java
. Maintenant nous devons compiler le fichier source. Le tutorial a besion de la librairie "lg3d core", et de java 1.5 pour se compiler. La librairie "lg3d core" peut être trouvée dans répertoire lib de lg3d. (remplacez $LG3DHOME avec le chemin vers lg3d).
javac -cp "$LG3DHOME/lib/ext/lg3d-core.jar" Tutorial2.java
Étape 9: Lancer l'application
Pour lancer le tutorial, exécutez le script "runtutorial" avec le même nom que le fichier class (sans l'extension .class)
    ./runtutorial Tutorial2
Le bureau de Looking Glass devrait s'afficher avec une boite vert clair au centre (comme vous le voyer ci-dessous). Quand la souris est bougée au-dessus, le curseur devrait changer, et la boite devrait prendre plus d'ampleur. The lg3d desktop should be displayed with a pale green (translucent) box in the center (as you see below). When the mouse is moved over it the cursor should change the movement cursor, and the box should increase in size for have a second. Testez votre application avant de passer au prochain tutorial qui couvrira d'avantage l'intéraction avec l'utilisation, et un exemple simple d'utilisation des textures.
The rotated pale green box from Tutorial2