Discussion :

[James k.]

Bonjour à tous,

Je vous contact afin d'obtenir plusieurs informations concernant le développement d'applications dans lesquels je souhaite utiliser Opengl ES 2 (Développement Android). Après avoir fait beaucoup de recherches sur internet, il s'avère que les tutoriels ne sont pas toujours très clair.

J'ai cru comprendre qu'il était obligatoire d'utiliser les shaders pour afficher n'importe quelle forme de base à l'écran avec Open GL ES 2.0. je me suis donc coder deux petites classes "Shader" et "Program" pour me faciliter la tache.

Seulement j'arrive au moment ou je dois afficher des objets à l'écran.

Pour optimiser l'affichage, j'ai cru comprendre qu'il était important d'afficher toute la scène en une seule fois avec un "glDrawElements", est-ce que c'est correct ?

Concernant l'affichage des objets, j'ai crée des types de bases "Circle", "Square" et "Triangle". Si l'utilisateur souhaite afficher un carré, il crée un donc un "Square" s'occupant de créer les sommets de ce polygone ainsi que ses indices. Jusqu'a la, est ce que tout est correct ?

Enfin, j'ajoute chacune des ces entités dans un tableau commun contenant tout les sommets à afficher ainsi qu'un second tableau contenant les indices. Je voudrais savoir comment je doit faire pour m'occuper des translation ou encore rotations de chacune de ses entités, doit-je le faire dans une méthode de l'objet ?

Je souhaite enfin obtenir une vue en 2D, seulement je n'arrive pas à placer correctement la caméra. (J'ai réussi à le faire avec OpenGl ES1 seulement)

Voici un résumé de l'affichage des éléments par rapport à ce que j'ai compris :

1 - Création d'un tableau commun contenant tout les sommets du programme
2 - On souhaite ajouter un cube
2.1 - Création de la forme du cube
3 - A chaque tour de boucle, on vide le tableau commun, puis on parcours toutes nos entités possédant une méthode "draw"
3.1 - Pour chaque entité on effectue nos transformations
3.2 - On l'ajoute au tableau commun
4 - On affiche la scène à l'aide des shaders et de "glDrawElements" (on lui fourni le tableau commun).


Merci beaucoup à vous d'avoir pris le temps de me lire.
En espérant une réponse de votre part.

Ps : J'ai acheté le livre "OpenGl Es2 programming guide" mais cela reste flou, l'auteur ne s'attaquant qu'a l'affichage d'un unique polygone à l'écran.

[le_ptit_lutin]

Salut,

Effectivement, OpenGL ES 2.0 oblige l'utilisation des shaders, c'est un peu comme OpenGL 3.0.

Sinon pour l'optimisation, il faut effectivement éviter d'appeler trop souvent des commandes de dessins en rassemblant au mieux ce qu'il y a dessiner et de préférence uniquement ce que la camera sera susceptible de voir.

Des techniques prévoit effectivement de mettre toute ta géométrie dans un unique tableau. Mais tu devras quand même utiliser plusieurs fois glDrawElements() avec des paramètres pour ne dessiner que l'objet désiré. Parce ce qu'on arrive a ta question suivante, tu dois mettre à jour ta matrice de transformation en fonction de l'objet que tu comptes faire bouger.

Donc pour un scène simple : un sol, un bonhomme et une maison par exemple. Tu devrais au mieux avoir 3x la commandes glDrawElements. Avant chaque appel, tu devras ajouter les transformations de l'objet (scale, rotation, translation) à ta matrice de projection, l'envoyer au program et enfin lancer la commande de dessin.

Il ne faut pas créer un nouveau tableau contenant la géométrie transformée et l'envoyer à OpenGL a chaque frame, c'est l'inverse de l'optimisation ça . Le but est bien de ne créer le tableau de géométrie et l'envoyer qu'une seule fois.

[James k.]

Merci beaucoup pour ces précisions,

Aurais-tu un exemple de caméra utilisant OpenGL ES 2 ? Ou alors juste le principe d'utilisation de la matrice de projection / les matrices de rotation ?

J'ai tenté quelque chose mais je me retrouve avec une scène vide, pas facile de débogueur OpenGL :s.

Merci encore !

[le_ptit_lutin]

Un exemple complet est un peu long. Mais théoriquement :

- On crée le view port avec glviewport() (la zone physique d'affichage)
- On crée une matrice de projection 3D. Etant donné que OpenGL ES 2/OpenGL 3 a lâché la gestion des matrices, tu peux utiliser GLM http://glm.g-truc.net/ pour faire tes premiers tests.
- On crée un program de rendu basic. OpengGL ES 2 ne donne plus de programme de rendu par defaut.
- On crée un tableau contenant une géometrie (exemple un cube). Il faut bien imaginer que cet objet a son propre cadre. C'est-a-dire que sa position/rotation est indépendante du cadre global de ton monde virtuel.
- On envoit ce tableau de données dans OpenGL en créant un VBO. glGenBuffer(), glBufferData(), ... Il faut également activer les bon attributs (position, normal, couleurs, ... ).

La on arrive dans la boucle de dessin.

- On réinitialise l'image. glClear()
- On utilise notre program de rendu. glUseProgram()
- On prépare une matrice de vue, c'est-a-dire qu'on transforme notre matrice de projection par la position de notre camera (Qui est en fait un point fictif dans le monde virtuel)

Pour chaque objet :
- On lie notre VBO concernant l'objet. glBindBuffer()
- On crée une matrice propre à l'objet. On utilise la matrice de vue et on la transforme par la position/rotation de l'objet.
- On envoie cette matrice au program. glUniform()
- On dessine enfin l'objet. glDrawElements()

- On clos le rendu avec la fonction du framework que tu utilises. Exemple pour SDL 1.3 c'est SDL_GL_SwapWindow()

Et on recommence. Voila plus ou moins un schéma théorique d'affichage.