Robot articulé 3D OpenGL

L'idée de base de ce projet  était simple : réaliser un robot 3D articulé. Il nous était imposé d’utiliser openGL (c’est notamment la technologie que nous maîtrisons le mieux à l’ESGI) et le C++. Le but de ce projet était donc de s’illustrer dans  la modification de la position des parties du corps d’un robot. Nous verrons dans la suite de cet article comment cela fonctionne. Pour tout vous avouer, je suis particulièrement fan de formes géométriques sphériques, raison pour laquelle je me suis dit : ”pourquoi ne pas faire un robot qui aurait la forme d’une boule ?”. Je me suis accroché à cette idée et me suis demandé ce je pourrait bien faire d’une boule. Bien évidemment, la réponse logique fut : éclater la boule pour avoir différents morceaux que je pourrais manipuler à ma guise !.

Stack technique

openGL + SDL en C sous codeBlock

Etape 1 : Par quoi commencer?

J’ai commencé par ouvrir 3Dsmax et faire une sphère grossièrement lowpoly (c.a.d 12 segments) afin d’obtenir les coordonnées de chacune des parois de la sphère : donc sa coque. Puis j’ai créé une deuxième sphère à l’intérieur de la première afin de donner une épaisseur à ma coque.

A l’aide d’une opération booléenne j’ai soustrais à la sphère supérieure, la sphère inferieure, puis, après avoir converti mon morceau de sphère en polygone éditable,  j’ai enlevé les parties de la coque qui étaient redondantes pour ne garder que les coordonnées qui m’étaient vraiment utiles. En effet, le dessus de la coque est identique au dessous et toutes les parties du dessous de la sphère sont semblables. J’ai ainsi obtenu trois morceaux. A la suite de cela, j’ai enregistré manuellement chacun des points de mon morceau de sphère.

Damien Leroux Robot 11

Damien Leroux Robot 12

Damien Leroux Robot 13

Etape 2 : L’armature de ma sphère

Une fois mes points récupérés, j’ai créé mon projet C++, inclu mes librairies openGL et  créé les 3 parties de mon morceau de sphère. Il m’a suffit, par la suite, de réafficher mon morceau de sphère avec une rotation de 30°, 60°,etc… ce qui a fermé la partie inférieure de ma sphère. J’ai reproduis l’opération pour obtenir la partie supérieure de ma sphère.  Et voila ! J’avais obtenu exactement la même sphère que celle créée sous 3dsMax.

Afin de pouvoir juger de la qualité de mon robot OpenGL, qui est une boule, j’ai repris le principe de trackball pour une planète. Mes premiers pas pour ce qui est des trackballs se sont faits grâce à un très bon tutoriel de  Kayl sur : site d'OpenClassRooms: la caméra. J’ai modifié légèrement l’algorithme afin de le faire cadrer avec mon repère et de pouvoir faire autant de rotations verticales que l’on souhaite.

Pour pouvoir mouvoir certaines parties de la boule, j’ai ajouté des contraintes sur l’affichage de l’armature de la sphère ce qui a laissé des blancs dans la sphère. J’ai ensuite affiché de manière précise les parties manquantes qui deviendront les membres du robot OpenGL(tète, pied, main..).

Etape 3 : L’intérieur de la sphère

Damien Leroux Robot explication construction fr

A l’intérieur de  ma sphère, je devais faire tenir : les bras, les jambes, le canon, le pivot de la tête. Cette contrainte n’a pas été la plus difficile, le plus gros travail a été de lier chacune des parties du corps entre elles. Prenons l’exemple d’une  jambe. Il a fallu déplacer, au centre de l’espace openGL, les 4 morceaux de sphère qui composent le pied. Ensuite, j’ai positionné l’un des 4 orteils au centre, puis créé une petite boule pour faire une jointure, déplacé cet ensemble et ajouté un cylindre. J’ai reproduis cette opération pour chaque orteil. J’ai ensuite créé une boule à l’intersection des 4 cylindres afin d’obtenir une jointure principale. Pour la création de la jambe, des déplacements (translatef), rotations (rotatef), créations de cylindres et de boules ont permis d’obtenir une jambe complète. Pour replacer correctement les 4 orteils sur leur position d’origine sur la sphère, toutes les modifications de rotation et de translation qui avaient été effectuées, ont du être reproduites dans  l’ordre inverse. Des calibrages sont bien entendu nécessaires  afin qu’aucune partie de la jambe ne s’entrechoque avec une autre ou avec la sphère. Pour toutes les autres parties du corps, la méthode est la même : partir du centre de l’espace openGL, utiliser des rotations et des translations ( pourquoi pas des transformations) afin de rajouter des  membres et jointures, faire le chemin des rotations et translations en sens inverse. Cela permet que les parties du membre qui font aussi office de coque se replacent correctement sur la boule. Enfin, il est nécessaire de calibrer la position des parties du membre afin qu’il n’y ait pas  d’entre-chocs.

Etapes  4 : Mouvoir le robot OpenGL

Le temps et la distance: ce sont les éléments utilisés afin de mouvoir les membres du robot. De ce fait, pour reprendre l’exemple d’une jambe, je calibre la vitesse et la distance avec laquelle elle sort du robot .

Un mouvement d’une partie de la jambe par rapport à une autre se fait uniquement à l’aide de rotations sur les jointures. C’est d’ailleurs là tout l’intérêt de s’ obliger à faire passer toutes les jointures, à un moment ou à un autre, au centre du repère openGL, car cela permet de calibrer une rotation sur la jointure. J’ai donc, pour ma part, créé un tableau X contenant tous les angles de rotations des jointures à atteindre  lorsque le robot est complètement ouvert. Un autre tableau Y contenant les valeurs effectives de ces angles à un instant t. Et enfin, une fonction, se basant sur le temps que j’ai choisi pour l’ouverture et le dépliage d’une partie du corps, affecte à Y sa valeur en fonction de X et de t.

Tous les angles contenus dans Y sont directement ajoutés aux diverses rotations  qui se produisent lors de la création d’un membre dans le robot.

Pour ce qui est de refermer le robot, une fonction décrémente les différents angles de Y jusqu'à 0 afin que le robot retrouve sa forme d’origine : une sphère.

Etape 5 : L’aspect général du robot

Au fur et à mesure que je construisais et paramétrais mon robot, je me suis demandé par quel moyen je pourrais améliorer l’esthétique de celui-ci : comment obtenir une vraie sphère et pas un lowpoly. Après quelques recherches : impossible de trouver une belle fonction toute pré-faite qui me donne des morceaux de sphères de meilleure qualité (je me doutais que je ne trouverais rien mais il important de savoir si quelque chose existe déjà avant de s’embêter à le créer : gros gain de temps). En fin de compte, j’ai créé, en me documentant sur internet, un « petit » algorithme qui me permet  de créer des parties de sphère, de la taille que je voulais, avec la résolution que je souhaitais et d’une épaisseur voulue. Une fois cette fonction créée, tout était permis :

  • la création de doigts pour les mains : ceux-ci  ne représentent que des petits morceaux de la sphère.
  • faire une tête en pointe : en surélevant, sur tout angle, chaque partie de l’arrière de la tête.
  • créer des parois rétractables pour laisser sortir les canons
  • créer des rectangles qui sortent du dos du robot pour faire office de réacteur.
  • supprimer tous les points que j’avais enregistrés avec 3Dsmax.

Etape 6 : Les finitions

Damien Leroux Robot 1

Deux aspects importants d’un rendu 3D étaient encore à mettre en œuvre : la texture et la lumière. Pour ce qui est des textures de mon robot,  je les ai faites sous Photoshop.  A la suite de cela, dans mon programme openGL, j’ai fais un petit algorithme afin que les textures s’appliquent correctement sur chaque morceau de mon robot. J’ai de même appliqué ces textures sur les autres composants du robot : les boules et cylindres. Là, aucun algorithme en particulier n’a du être inventé pour que la texture s’applique correctement (Les quadriques et textures faisant bon ménage). Pour ce qui est du chargement des textures (.jpeg), j’ai utilisé le tutoriel décris ici : Textures OpenGL réalisé par Kayl.

Damien Leroux Robot 2

La lumière : une autre paire de manche, j’ai même bien failli ne pas en mettre du tout ! En effet, j’ai mis un certain temps à comprendre comment fonctionne la lumière et les quads (petits carrés qui forment ma sphère). Sous openGL, dès que l’on créait des quads, quelle que soit leur position, ils ont tous la même normale qui leur est attribué par rapport à la lumière. Il a donc été nécessaire de faire un algorithme qui me calcule la normale sur chaque quad par rapport à la lumière et affecte cette normale au quad correspondant lorsque celui-ci est créé.

Pour le fond, j’ai opté pour une skybox : un moyen toujours assez simple d’avoir un fond sans  « manger » trop de ressources. Pour cette skybox, j’ai suivi le tutoriel suivant :Skybox OpenGL .j’ai remodelé quelque peu l’algorithme (le code en l’occurrence) qui était fourni, notamment afin de le mettre en adéquation avec la position de ma caméra qui évolue grâce au trackball. Je l’ai aussi modifié afin de remplacer la prise en charge de bitmap, par la prise en charge de jpeg (bien plus léger ^^).

Le resultat final

Damien Leroux Robot 3

Damien Leroux Robot 4

Damien Leroux Robot 6

Damien Leroux Robot 7