GLam Collection version 0.4 - | ACCUEIL - CLASSES - HIERARCHIE - MEMBRES - EXEMPLES |
Interface de développement g++/OpenGL. Plus de détails...
#include <glamwindow.h>
Fonctions membres publiques | |
GLamWindow (const string &title="GLam", int width=800, int height=800) | |
~GLamWindow () | |
void | run () |
void | setBackgroundColor (float r, float g, float b) |
void | setLightPosition (const XamPoint &pos, bool positional=true) |
XamPoint | lightPosition () const |
Fonctions membres protégées | |
virtual void | createObjects () |
virtual void | drawObjects () |
virtual void | animateObjects () |
virtual void | keyPressEvent (unsigned char key) |
virtual void | selected (int idParent, int idObj) |
Interface de développement g++/OpenGL.
La classe GLamWindow propose une base GLUT de développement.
Elle assure la préparation de la scène OpenGL en mettant en place un éclairage et en activant le tampon de profondeur (z-buffer). La scène est de dimensions 16 x 16.
Elle propose un modèle de développement permettant de faire apparaître des objets sur la scène. Ce modèle se résume à 5 méthodes virtuelles protégées :
La boucle d'événements est déclenchée par appel à la méthode publique run().
La classe GLamWindow offre un certain nombre de commandes de manipulation de la scène. Elle assure notamment la mise en place des mécanismes de picking permettant une sélection d'objets sur la scène par action sur le bouton central de la souris.
Fonction | Description | ||
---|---|---|---|
Trackball virtuel | souris | mouvement + bouton gauche | rotations autour des axes X et Y |
mouvement + bouton droit | rotation autour de l'axe Z | ||
Zoom | souris | rotation molette | réduction/agrandissement par pas de 10% |
Décalage du point de vue | clavier | flèche gauche | décalage vers la gauche |
flèche droite | décalage vers la droite | ||
flèche haut | décalage vers le haut | ||
flèche bas | décalage vers le bas | ||
touche Home | vue centrée sur l'origine 0XYZ (défaut) | ||
Vues ISO | clavier | Ctrl + flèche gauche | vue de droite |
Ctrl + flèche droite | vue de gauche | ||
Ctrl + flèche haut | vue de dessous | ||
Ctrl + flèche bas | vue de dessus | ||
Ctrl + touche Home | vue de face (défaut) | ||
Ctrl + touche End | vue arrière | ||
Animation | clavier | touche A | [dés]activation de la rotation autour de l'axe Z |
touche + | augmentation de la vitesse de rotation | ||
touche - | diminution de la vitesse de rotation | ||
Position de l'éclairage | clavier | Shift + flèche gauche | vers la gauche (X-) |
Shift + flèche droite | vers la droite (X+) | ||
Shift + flèche haut | vers le haut (Y+) | ||
Shift + flèche bas | vers le bas (Y-) | ||
Shift + touche PageUp | vers l'arrière (Z-) | ||
Shift + touche PageDown | vers l'avant (Z+) | ||
Sélection d'objets | souris | bouton central | appel de la méthode virtuelle selected() |
Fermeture de l'application | clavier | touche Esc |
La lampe par défaut est une lumière blanche de type positionnel, elle est localisée en { 5, 5, 10 }.
La classe propose des possibilités de déplacer la lampe au moyen du clavier ; chaque action laisse apparaitre la lampe pendant un court instant (environ 1 seconde) sous la forme d'une petite sphère rouge.
Pour exploiter la bibliothèque GLam, une application doit tout simplement disposer d'une classe dérivée de GLamWindow telle que le modèle suivant :
// myoglappli.h #ifndef MYOGLAPPLI_H #define MYOGLAPPLI_H #include <GLam/glamwindow.h> class MyOglAppli : public GLamWindow { Q_OBJECT public : MyOglAppli(const string& title = "GLam", int width = 800, int height = 800 ) ; ~MyOglAppli() ; void createObjects() ; void drawObjects() ; void animateObjects() ; void keyPressEvent(unsigned char key ) ; void selected(int idParent, int idObj ) ; private : // objets GLam membres } ; #endif
GLamWindow::GLamWindow | ( | const string & | title = "GLam" , |
|
int | width = 800 , |
|||
int | height = 800 | |||
) |
Constructeur
GLamWindow::~GLamWindow | ( | ) |
Destructeur
void GLamWindow::animateObjects | ( | ) | [protected, virtual] |
Animation de la scène, avec une périodicité de 20 ms.
Cette méthode peut être surchargée dans la classe d'application cliente sans remettre en cause l'animation proposée par défaut (rotation autour de l'axe Z).
Exemple de surcharge dans une classe d'application nommée MyOglAppli
dérivée de GLamWindow. Cet exemple reprend celui de la classe GLamSpring avec spring1
en tant que membre privé et provoque un mouvement alternatif extension/compression du ressort :
void MyOglAppli::animateObjects() { static double springLen = 5 ; static int sign = 1 ; spring1->setLength( springLen ) ; if ( ( springLen >= 5.0 )&&( sign == +1 ) ) sign = -1 ; if ( ( springLen <= spring1->minLength() )&&( sign == -1 ) ) sign = +1 ; springLen += sign * 0.2 ; }
void GLamWindow::createObjects | ( | ) | [protected, virtual] |
Création de 2 objets de base : un trièdre et une grille de référence 16x16.
Cette méthode doit être surchargée pour assurer la création des objets de l'application cliente. La création des 2 objets de base peut être conservée ou non...
Exemple de surcharge dans une classe d'application nommée MyOglAppli
dérivée de GLamWindow. Cet exemple reprend celui de la classe GLamCube avec les objets cube1
, cube2
, et cube3
en tant que membres privés :
void MyOglAppli::createObjects() { GLamWindow::createObjects() ; // objets de la classe de base cube1 = new GLamCube(3, 2.4, 1.3 ) ; cube1->setColor(0.8, 0.1, 0.0 ) ; cube2 = new GLamCube( *cube1 ) ; cube2->setColor(0.0, 0.8, 0.2 ) ; cube2->setThickness(0.5 ) ; cube3 = new GLamCube(2, 4, 0 ) ; }
void GLamWindow::drawObjects | ( | ) | [protected, virtual] |
Projection des objets sur la scène.
Cette méthode doit être surchargée pour assurer la projection des objets de l'application cliente. La projection des 2 objets de base peut être conservée ou non...
Exemple de surcharge dans une classe d'application nommée MyOglAppli
dérivée de GLamWindow. Cet exemple reprend celui de la classe GLamCube avec les objets cube1
, cube2
, et cube3
en tant que membres privés :
void MyOglAppli::drawObjects() { GLamWindow::drawObjects() ; // objets de la classe de base glPushMatrix() ; cube1->draw() ; glTranslated( 5.0, 0.0, 0.0 ) ; cube2->draw() ; glTranslated( -2.0, -3.0, 3.0 ) ; glRotated(-45, 1, 1, 0 ) ; cube3->draw() ; glPopMatrix() ; }
void GLamWindow::keyPressEvent | ( | unsigned char | key | ) | [protected, virtual] |
Intercepteur des événements liés au clavier. Cette méthode virtuelle permet à l'application cliente de récupérer les codes clavier (ASCII). L'animation contrôlée par les touches 'a','-' et '+' peut être conservée en invoquant explicitement dans la surcharge la méthode homonyme de la classe de base.
Exemple de surcharge dans une classe dérivée d'application nommée MyOglAppli
afin d'animer la pince de robot au moyen de la touche P du clavier :
void MyOglAppli::keyPressEvent(unsigned char key ) { switch( key ) { case 'P' : if ( delta <= 6.0 ) delta += .2 ; break ; case 'p' : if ( delta > -6.0 ) delta -= .2 ; break ; } GLamWindow::keyPressEvent( key ) ; }
XamPoint GLamWindow::lightPosition | ( | ) | const |
Retourne la position courante (x,y,z) de la lampe.
void GLamWindow::run | ( | ) |
Démarrage de la boucle d'événements. Le seul moyen de sortir de cette boucle est de fermer la fenêtre graphique soit par la croix en haut à droite fournie par le Window Manager, soit par appui sur la touche d'échappement (Escape) du clavier.
void GLamWindow::selected | ( | int | idParent, | |
int | idObj | |||
) | [protected, virtual] |
Méthode invoquée lors de la sélection d'un objet sur la scène, ou lors de la désélection de l'objet en cours de sélection.
L'argument idParent représente l'identifiant de la display list du parent de l'objet sélectionné lorsque cela est possible, ou 0 sinon. L'argument idObj contient l'identifiant de l'objet proprement dit.
Si il s'agit d'une désélection, les 2 arguments sont à 0.
Exemple de mise en place d'une surcharge dans une classe d'application nommée MyOglAppli
dérivée de GLamWindow. L'aspect de l'élément sélectionné est modifié par appel à la méthode GLamObject::setSelected(), et des informations d'usage sont envoyées sur la console (clause MYDEBUG) :
void MyOglAppli::selected(int idParent, int idObj ) { static GLamObject* currentSelection = NULL ; if ( idParent == 0 && idObj == 0 ) { if ( currentSelection != NULL ) currentSelection->setSelected( false ) ; return ; } GLamObject* obj = GLamObject::objectAddress( idParent ? idParent : idObj ) ; if ( obj != NULL ) { if ( currentSelection != NULL ) currentSelection->setSelected( false ) ; obj->setSelected() ; currentSelection = obj ; } #ifdef MYDEBUG cout << "--> id : " << idObj ; cout << ", class : " << GLamObject::objectClass(idObj ) ; cout << ", name : " << GLamObject::objectName( idObj ) ; if ( idParent ) { cout << " --- parent : " << idParent ; cout << ", class : " << GLamObject::objectClass(idParent ) ; cout << ", name : " << GLamObject::objectName( idParent ) ; } cout << endl ; #endif }
void GLamWindow::setBackgroundColor | ( | float | r, | |
float | g, | |||
float | b | |||
) |
Fixe la couleur de fond de la scène (blanche par défaut).
Les proportions RGB sont transmissibles sous forme de valeurs réelles dans l'intervalle [0;1] (pourcentage/100) ou sous forme de valeurs entières ]1;255] (proportion codée sur 8 bits).
void GLamWindow::setLightPosition | ( | const XamPoint & | pos, | |
bool | positional = true | |||
) |
Fixe la position (x,y,z) de la lampe d'éclairage de la scène.
L'argument positional permet de choisir entre un éclairage de type ponctuel (défaut) ou directionnel.