FAQ (en construction...)

(questions et problèmes les plus fréquemment rencontrés en TP)

• Un problème avec l'éclairage
• Un problème avec les faces cachées
• Un problème avec la transparence
• Charger un objet graphique prédéfini
• Trouver l'objet graphique qui se trouve sous le curseur
• Les FAQ plus longues
  • http://www.opengl.org/resources/faq/
  • http://www.j3d.org/matrix_faq/matrfaq_latest.html

Un problème avec l'éclairage

Les problèmes avec l'éclairage peuvent venir de bugs divers et variés... Voilà une checklist de ce qu'il faut vérifier pour, au moins, éviter les bugs de base:

• Les normales sont bancales
  • Elles ne sont pas déclarées => il faut le faire !! cf glNormalfv
  • Elles sont déclarées par glNormalfv, mais les coordonnées ne sont pas correctes -> afficher les avec le reste de votre volume pour les vérifier. Alternativement, vous pouvez aussi remplacer votre objet par affichage d'un objet prédéfini comme le cube ou la sphere pour lesquels les normales sont correctes (cf glutSolidCube / glutSolidSphere.)
• Les paramètres de la lumière sont incorrects:
  • Rappel préliminaire: si vous ne modifiez pas les paramètres de la lumière ils sont aux valeurs par défaut.
  • La lumière est placée à l'intérieur du volume ou derrière le volume.
  • La lumière tourne avec la scène car la position de la lumière est affectée par la matrice de modélisation courante. Pour obtenir une lumière fixe, il faut définir la position avant de modifier la matrice de modélisation par des transformations diverses (telles que gluLookAt, glRotate, glTranslate, etc...)
  • La lumière est placée à l'infini (vous pouvez le faire en donnant 0 pour la coordonnée homogène de la position de la lumière), elle donne un éclairage équivalent à une lumière ambiante => pour un éclairage du style d'une lampe la coordonnée homogène de la position de la lumière doit être à 1.
• Les paramètres des matériaux sont incorrects:
  • Rappels préliminaires:
    • si vous ne modifiez pas les paramètres des matériaux ils sont aux valeurs par défaut.
    • Vous avez deux manières d'agir sur les paramètres des matériaux:
      • Vous utilisez glMaterialfv(mode,couleur) à la place de glColor3f(couleur), c'est alors glMaterialfv qui déterminera la couleur de votre objet. Attention, le paramètre mode explicite la composante de la lumière émise qui prendra la couleur du paramètre color. Pour un vertex donné, on peut mettre un niveau de gris pour la composante ambiante, une couleur franche en diffuse et un mélange en spéculaire par exemple.
      • Si vous utilisez glColorMaterial(face,mode), vous pouvez continuer de spécifier les couleurs par glColor*. En d'autres termes, un appel à glColorMaterial(GL_FRONT, GL_DIFFUSE) par exemple aura pour effet de donner un sens particulier à tous les prochains appels de glColor*: la couleur spécifiée par glColor ne concernera plus que la composante diffuse des faces avant. Attention à deux choses: (1) pour que les appels à glColorMaterial soient suivi d'effet, il faut avoir activé ce mode par un appel à glEnable(GL_COLOR_MATERIAL)et (2) l'instruction vaut seulement pour la composante stipulée dans mode et portera sur tous les sommets définis après sauf à faire un appel à disable(GL_COLOR_MATERIAL). Les autres composantes seront aux valeurs par défaut
      • NB: pour la transparence, c'est la composante alpha de la composante diffuse du matériau qui est utilisée.
      • NB2: conseil pour le beginner: choisir la première manière (e.g. appels à glMatérialfv) est peu optimal mais permet de mieux comprendre ce que l'on fait aussi.
  • Les paramètres des matériaux sont incompatibles avec ceux de la (des) lumières présentes.
  • Si vous utilisez des glColor* pour définir les couleurs de vos objets et que tout est gris mais l'impression de lumière existe: vous devez utiliser les paramètres des matériaux pour changer la couleur (et éventuellement abandonner vos appels à glColor*).
    

Un problème avec les faces cachées

Quelle technique avez vous utilisé pour éliminer les faces cachées? Vous pouvez utiliser

• Elimination des faces arrières ou Culling. Pour cela il vous faut simplement:
  (1) avoir correctement orienté vos faces et
  (2) utiliser glEnable(GL_CULL_FACE)
  NB: ce calcul est très léger pour gl et il permet d'éliminer bcp de facettes avant de faire les calculs de rendu, on a donc toujours intérêt à le faire sauf lorsque l'on a de la transparence par dessus des facettes arrières...
Par contre, de nombreux cas de faces cachées ne sont pas résolus par cette technique, en particulier lorsqu'un objet se trouve devant un autre objet.
• Vous utilisez le depth-buffer.
  Le depth-buffer élimine toutes les faces cachées hormis les problèmes de facette se recouvrant dans un même plan. Si votre mise en oeuvre du depth-buffer ne fonctionne pas, vérifiez que vous avez bien effectué les trois étapes clés:
  • initialisation correcte de votre fenêtre de départ pour avoir une utilisation du depth-buffer en passant GLUT_DEPTH dans la liste des paramètres de glutInitDisplayMode comme par exemple comme cela: glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
  • initialisation correcte du depth-buffer à chaque début de dessin par :
    glClearDepth(1.0);
glClear(GL_DEPTH_BUFFER_BIT);
  • prise en compte du depth-buffer par :
    glEnable(GL_DEPTH_TEST);
  NB: la mise en oeuvre du depth-buffer est plus coûteuse que le culling dans la mesure où elle se fait après que les facettes aient été entièrement calculées par une comparaison pixel à pixel. On pourra combiner les deux techniques le plus souvent en commençant par le culling pour économiser le calcul des facettes et la comparaison pixel à pixel pour les facettes arrières.

Un problème avec la transparence

Il peut y avoir de nombreux bugs faisant apparaître des problèmes de transparence. Voilà les bugs les plus répandus lors des TPs sur le cube pour ceux qui ont voulu faire toutes les faces transparentes, ceux qui ont voulu faire transparence et culling, ceux qui ont voulu faire transparence et depth-buffer.

• Premier symptôme: toutes les faces sont transparentes sauf une qui reste noire. C'est la première face dessinée qui est noire ou du moins très foncée et votre fond est noir? Si c'est votre cas, c'est simplement que la transparence de la première est calculée par un mélange de couleur entre le fond noir et la couleur de la facette. En fonction de votre alpha, le résultat peut donner quelque chose d'assez foncé et très uniforme puisque le fond est de la même couleur partout. Les facettes qui vont se dessiner par dessus cette première facette par contre auront l'air plus transparentes, parce que (1) elles se dessinent par dessus un fond qui n'est plus uniforme: il est composé de l'ensemble des facettes qui ont été dessinées avant elles. Il y a donc un effet de transparence plus intéressant. On peut contourner ce problème en utilisant l'algo du peintre par exemple, mais l'implémentation n'est pas immédiate, c'est pourquoi dans le TD on vous demande d'avoir une seule facette transparente et si vous voulez que cela se passe bien un conseil: dessiner la facette transparente APRES toutes les autres la dernière.
• Transparence et culling: vous avez utilisé du culling (ie glEnable(GL_CULL_FACE)) pour l'élimination des faces arrières, du coup vous n'avez plus de faces arrières et la transparence est calculée comme un mélange avec le fond. Cela peut donner des résultats divers, parfois même passer inaperçu en fonction de l'objet transparent et de son fond. Parfois même donner l'effet souhaité... Mais sauf à savoir vraiment ce que l'on fait, en règle générale, on n'utilisera pas le culling lorsque l'on veut faire de la transparence (NB: il peut être activé sur d'autres régions de la scène et on le désactive lors du dessins des facettes intéressantes en faisant glDisable(GL_CULL_FACE))
• Transparence et depth-buffer: vous utilisez le depth-buffer pour l'élimination des faces arrières et vous souhaitez faire de la transparence. C'est faisable mais attention... Le depth-buffer dans son mode normal traite les facettes transparentes comme les autres: il remplace la valeur de depth se trouvant dans le depth-buffer par les valeurs correspondants à la facette transparente lorsque vous la dessinez. Du coup si, après avoir dessiné une facette transparente, vous dessinez un objet derrière cette facette, le depth buffer ne dessinera pas l'objet (puisqu'il est derrière...). Comment contourner le problème: (1) dessinez les facettes transparentes après toutes les autres ou (2) lorsque vous dessinez votre facette transparente mettez le depth-buffer en read-only, pour éviter qu'il tienne compte de cette facette. Pour mettre le depth-buffer en read-only: glDepthMask(GL_FALSE) -> read-only, glDepthMask(GL_TRUE)->mode normal.

Charger un objet graphique prédéfini

On trouvera sur le web des objets au format .obj (format alias dont les spécifications peuvent être trouvées ici). On peut s'inspirer des exemples de Nate Robins. On peut aussi créer ses propres objets en utilisant un modeleur avec un export au format .obj. Les modeleurs sont nombreux (le plus souvent ils ont un export au format .obj).

• Vous trouverez une copie des objets extraits du site de Nate Robins
• glm.c, glm.h: le code de Nate Robins permettant de charger un fichier .obj et .mtl
• un exemple comme transformation.c de l'utilisation de glm.c et glm.h (attention pour l'utiliser il faut avoir les données associées aux objets définis installés dans le répertoire data du répertoire de travail. Regarder le code avant de compiler...)

Les textures

Pour commencer les notes de cours sont ici

Trouver l'objet graphique qui se trouve sous le curseur

Il y a plusieurs manières possible une ligne, une première solution est dans le programme d'exemple pickSquare.c extrait des exemples SGI.
Quelques explications supplémentaires ne sont pas de trop. Elles se trouvent ici:

• http://www.opengl.org/resources/faq/technical/selection.htm
• Ou bien si on préfère le français : http://raphaello.univ-fcomte.fr/IG/OpenGL/OpenGL-3.htm#selectionObjets ou http://devernay.free.fr/cours/opengl/makeslide/selection/overview.htm
  On y trouve en plus des explications d'autres exemples.

Une alternative plus légère est aussi possible avec l'utilisation des fonctions gluProject ou gluUnProject.