Référence de la classe GLamObject

Classe de base abstraite. Plus de détails...

#include <glamobject.h>

Liste de tous les membres

Description détaillée

Classe de base abstraite.

La classe GLamObject est une classe abstraite servant de modèle de développement pour l'ensemble des classes de la bibliothèque GLam. Elle assure la gestion de la liste d'affichage d'un élément (OpenGL display list), le maintien des données liées à son rendu (couleur de base, matériau, ...), et permet de provoquer son affichage proprement dit.

La classe GLamObject se charge aussi de la gestion de la liste courante des objets. Elle maintient pour cela une table de correspondance entre les identifiants de display list et l'adresse mémoire des objets.
Chaque objet peut être nommé par setName(). Cette fonctionnalité peut faciliter l'identification des objets sur une scène complexe.
Si le «picking» (technique OpenGL) est mis en place, chaque objet peut donc être sélectionné sur une scène d'affichage et ses caractéristiques peuvent être atteintes grâce aux méthodes statiques objectClass(), objectName() et objectAddress().

La classe GLamObject est abstraite, les classes dérivées de spécialisation doivent implémenter la méthode virtuelle pure create() qui décrit la procédure OpenGL de dessin d'un objet, typiquement encadrée par des appels à glPushMatrix() et glPopMatrix(). Une classe dérivée de GlamObject utilisant d'autres objets enfants eux ausssi dérivés de la classe de base devra surcharger les méthodes virtuelles de classe de base -modificateurs de propriétés et méthode update()- afin d'en propager les effets vers ses enfants.

Propriétés

simpleColor : Indicateur de mode de rendu (couleur ou matériau). La valeur par défaut est true. Le mode simpleColor est activé automatiquement lors d'un appel à setColor().

• bool isSimpleColor () const ;
• void setSimpleColor (bool simpleColor = true ) ;

color : Couleur de l'objet en mode simpleColor. 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). Elles sont toujours retournées sous la forme [0;1]. La couleur par défaut est égale à {0.7,0.7,0.7}.

• float red () const ;
• float green () const ;
• float blue () const ;
• void setColor (float r, float g, float b, bool shiny = false ) ;

shiny : Aspect mat ou brillant en mode simpleColor. La valeur par défaut est false.

• bool isShiny () const ;
• void setShiny (bool shiny = true ) ;

material : Paramètres de réflexion de l'objet. Ces paramètres sont spécifiés sous forme d'un tableau de dix valeurs représentant successivement les proportions RGB de la réflexion ambiante, diffuse et spéculaire ; la dernière valeur correspond au coefficient de brillance codé entre 0.0 et 128.0. Tout appel à setMaterial() révoque automatiquement le mode simpleColor. La méthode material() avec un argument compris entre 0 et 9 permet de récupérer si nécessaire les caractéristiques de réflexion. Le matériau par défaut est fixé à (0.05,0.05,0.0, 0.5,0.5,0.4, 0.7,0.7,0.05, 10.0), ce qui correspond à un aspect «yellow rubber».

• float material (int i ) const ;
• void setMaterial (float mat[10] ) ;

thickness : Epaisseur de l'objet. Cette propriété correspond en général à la dimension suivant l'axe 0Z.

• double thickness () const ;
• void setThickness (double thickness )

Moteur de scène

La classe de base GLamObject propose un moyen d'appliquer des transformations un tout objet de classe dérivée. Le terme transformation regroupe toutes les possibilités de modifications géométriques de l'objet par rapport au repère de la scène dans laquelle il est projeté :

• translations suivant les axes X,Y ou Z
• rotations autour des axes 0X, 0Y ou 0Z
• changements d'échelle suivant les axes X,Y ou Z.

Les transformations sont en général appliquées par multiplications de matrices, il est donc possible de combiner plusieurs transformations soit directement au sein d'une même matrice, soit par applications successives de plusieurs matrices de transformations élémentaires.

Transformations courantes (animations...)

La méthode transform() retourne la matrice courante de transformation. Cette matrice correspond par défaut à la matrice identité, ce qui n'induit aucune transformation de la géométrie de l'objet par rapport à la scène.

La méthode setTransform(const XamMatrix& matrix ) applique la matrice transmise en argument en tant que nouvelle matrice de transformation. Pour appliquer une transformation supplémentaire sans annuler les transformations en cours, il suffit de combiner les matrices comme dans l'exemple suivant :

GLamObject* currentObject ;
XamMatrix matrix ;

... ...
matrix.toTranslate( 1.0, 2.0, 3.0 ) ;
currentObject->setTransform( currentObject->transform() * matrix ) ;
... ...

Les écritures peuvent être simplifiées grâce à la méthode multTransform(const XamMatrix& matrix ) qui multiplie la pile des transformations courantes par la matrice transmise en argument.
multTransform ( m ) est donc équivalent à setTransform( transform() * m ).

La méthode resetTransform() force le retour de la matrice de transformation à la matrice identité afin d'annuler toute transformation.

Transformations par défaut

Les méthodes defaultTransform(), setDefaultTransform(const XamMatrix& matrix ), multDefaultTransform(const XamMatrix& matrix ) et resetDefaultTransform() agissent de la même manière sur une deuxième pile de matrices prise en compte avant la pile de transformations courantes. Les transformations par défaut sont celles à appliquer pour fixer la position et l'orientation initiale de l'objet sur la scène, en évitant ainsi les traditionnels appels aux primitives OpenGL avant l'invocation de la méthode draw().

Exemple (extrait de celui de la classe GLamCube) :

// solution 1 :
// transformations initiales par primitives OpenGL

GLamCube* cube1 ;
GLamCube* cube2 ;
GLamCube* cube3 ;

// construction

cube1 = new GLamCube(3, 2.4, 1.3 ) ;
cube2 = new GLamCube( *cube1 ) ;
cube2->setThickness(0.5 ) ;
cube3 = new GLamCube(2, 4, 0 ) ;

// projection sur la scène

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() ;

// solution 2 :
// transformations initiales par GLamObject

GLamCube* cube1 ;
GLamCube* cube2 ;
GLamCube* cube3 ;

// construction et mise en scène

cube1 = new GLamCube(3, 2.4, 1.3 ) ;
cube2 = new GLamCube( *cube1 ) ;
cube2->setThickness(0.5 ) ;
cube3 = new GLamCube(2, 4, 0 ) ;

XamMatrix m1, m2 ;
m1.toTranslate( 5.0, 0.0, 0.0 ) ;
cube2->setDefaultTransform( m1 ) ;
m2.toTranslate(-2.0, -3.0, 3.0 ) ;
cube3->setDefaultTransform( m1 * m2 ) ;
m2.toRotate(-45, XamVector(1, 1, 0 ) ) ;
m2 = cube3->defaultTransform() * m2 ;
cube3->setDefaultTransform( m2 ) ;

// projection sur la scène

cube1->draw() ;
cube2->draw() ;
cube3->draw() ;

L'intérêt de la deuxième solution est que les transformations initiales sont maintenues par l'objet et non par le programme client...

Documentation des constructeurs et destructeur

Documentation des fonctions membres