Manipulation des pixel buffer objects

Bonjour tout le monde,

J'ai besoin de l'avis de connaisseurs en OpenGL à propos des PBOs. Il ne s'agit pas réellement de problèmes, mais plutôt de questions que je me pose vis à vis de l'emploi que j'en fais. C'est un peu une découverte/exercice.

Tout d'abord, j'ai eu besoin d'écrire du texte dans une application OpenGL, la première de mes solutions était d'avoir une simple texture avec un tableau de caractère disposer dans l'ordre ASCII. Puis d'afficher les caractères carré par carré. Les performances étaient juste catastrophique pour du texte dynamique, je précise que je me limite à utiliser les fonctions OpenGL 3.

Donc je me suis dit que j'allais plutôt faire une zone de texte, qui serait une texture sur laquelle j'allais simplement coller les lettres en pixel.
Donc, j'ai un PBO par lettre et c'est OpenGL qui gère le transfert du PBO à la texture, ce qui est beaucoup plus rapide pour afficher un texte puisque je ne dois plus régénérer de géométries et qu'il y a beaucoup moins d'opérations CPU/GPU.

Mais, ma première question est : Est ce qu'on est limité par le nombre de PBO qu'on alloue ? Dans le cas ou je veux faire de l'unicode par exemple, je vais devoir en allouer plus que 256 PBOs je pense :)

Sinon, et on arrive a ma deuxième question : Peut-on limiter les pixels que l'on transfert d'un PBO vers une texture ? Pour le moment, je bind un PBO sur UNPACK et j'utilise la fonction glTexSubImage2D() pour transférer sur la texture au bon endroit.
Je peux choisir où je colle, mais ce serait encore mieux de pouvoir choisir dans le PBO la partie que l'on souhaite copier. Comme ça, j'aurais un seul PBO avec toutes les lettres.

Ma troisième question, qui complète la deuxième finalement : Peut-on définir une méthode de transfert des pixels d'un PBO ? Je voudrais par exemple au lieu de remplacer, multiplier ou additionner pour faire des effets. Un peu à la manière de GL_BLEND. Ce serait énorme puisque cela me permettrait d'avoir des lettres de différentes couleurs et de réécrire par au dessus les autres lettres.

Voila. Il y a certainement de meilleurs méthodes pour afficher du texte avec OpenGL, si vous avez des solutions aussi rapide qui me permette de coller du texte sur n'importe quelle surface, je suis preneur.

Merci et bonne journée.

Salut,

Désolé de ne pas répondre à ta question, je ne connais pas trop les PBO. Mais ce qui m'étonne, c'est que la méthode avec la grille ASCII marche assez bien en général.
Une fois la texture et les display-list initialisés, tu fait juste un glListBase et un glCallLists de ta chaine de caractère et c'est bon. Pas de transfert CPU/GPU. Comment affichais-tu les quads des lettres ?

Les display lists appartiennent au siècle dernier, merci de ne plus les utiliser (ou les recommander) :P

Je sais pas trop quelle méthode est généralement utilisée pour opengl 3, mais un équivalent de la vieille technique devrait pas poser de problèmes. Est-ce que tu recrées ton quad pour chaque lettre ? Parce que ça, ça peut poser problème.

Citation:

---

Les display lists appartiennent au siècle dernier, merci de ne plus les utiliser (ou les recommander)

---

Oups, désolé, les vielles habitudes... :)

Donc l'idée, c'est d'avoir un texte qui peut changer entre chaque frame, donc j'aimerais éviter d'appeler une commande de dessin rien que pour chaque lettre.

Sinon pour un texte fixe, l'idée aurait été de générer un VBO temporaire avec tout le maillage nécessaire et les points de coordonnées pour afficher les bonnes lettres. Seulement ça ne convient pas dans mon cas.

En fait, j'ai besoin de faire une console. Mes premiers essais me faisait perdre 200FPS sur 700 pour afficher une histoire de 100 caractères.

Je crois que ce qu'il faut, c'est un vertex buffer assez long et statique, et quand tu appelles ton draw, tu met un nombre d’éléments plus petit pour dessiner que le début du buffer (sauf que je me souviens plus trop de comment ça marche, surtout sous opengl 3).

Ce n'est pas la taille du VBO qui pose problème, c'est devoir le mettre à jour qui coûte et l'emploi.

J'ai pensé mettre 256 quads avec les coordonnés de texture alignées sur la bonne lettre. Pour afficher une lettre particulière, il suffit de choisir d'où commencé l'indice et le nombre d'indice qu'on veut afficher avec les paramètres de glDrawElements(), donc tout ça c'est ok. Si je veux afficher une phrase de 15 caractères, le hic, c'est que je dois appeler 15 fois la commande... Ce qui m'embête un peu pour un simple quad. On peut penser a glMultiDrawElements(), seulement je ne peux plus déplacer la matrice pour décaler les lettres. Enfin je trouve pas de solution élégante en utilisant des quads, c'est pour ça que je me suis tourné vers la mise à jour d'une texture où tout ce fait directement dans la VRAM. Mais bon c'est la première fois que j'utilise les PBO, et il n'y a pas beaucoup d'articles sur ce système, même dans OpenGL superbible 5, je trouve que ça manque de détails.

Bon alors je vais peut être dire une absurdité sans nom, mais tu as pensé a l'instancing ? J'y connais pas grand chose, mais il semble qu'il suffit de passer une géométrie et une liste de paramètres pour pouvoir dessiner le même mesh de manière quelque peu différente a moindre cout. Il suffirait de lui donner ton quad et la liste de positions et coordonnées textures. Apres, je sais pas si ca existe vraiment sur OpenGL (et il me semble que sur Direct3D, la gain de performances n'est pas garanti et dépend de beaucoup de choses).

Oui j'y ai pensé, c'est une option fort récente apparement.

Dans le vertex shader, on peut utiliser le gl_instanceID qui donne le numero de la primitive en cours. Avec ça, on peut par exemple appliquer une modification particulière à chaque primitive, comme une position aléatoire.

Pour déplacer les quads, c'est cool, mais pour afficher les bonnes coordonées de texure, j'ai un peu calé, ça devenait un peu compliqué... Et je pense que c'est pas tout à fait adapté.

Il me semble que les coordonnées xy et uv devraient calculées coté cpu avant de tout envoyer dans un gros buffer (même s'il est vrai que les xy peuvent etre calculés niveau shader). Et qu'ensuite, dans le shader tout marche tout seul comme si tu dessinais normalement (ou alors il faut quand même utiliser l'id pour sélectionner les bonnes données dans le tableau, je sais pas trop).

Ben, l'exemple sur lequel je m'était basé partait de l'instanciation de 3 touffes d'herbes sur un plan. Techniquement il n'y avait que 3 appels et ils se servaient de gl_instanceID pour déposer aléatoirement l'herbe et même opérer quelques modifs très génériques sur l'instance.

Donc je me suis dit que ça ne pouvait pas me servir, a part imprimer 100x la lettre A de taille différente sur l'écran. :)

PS: sinon personne n'aime les PBO ??

Pourquoi tu demandes à OpenGL de générer ta texture (avec tes PBOs) plutôt que de le faire toi-même (ce qui n'est pas dur, je suppose), ce qui te permettrait d'éviter les PBOs qui, je pense, ne t'apporteraient rien.
En effet tu ferais ton calcul de texture côté CPU et tu passes ensuite la texture générée à la carte graphique.
Ca te permettrait en plus de faire le calcul de la texture hors de la boucle de rendu (contrairement aux PBO où il te faudrait un contexte actif)

Ce n'est pas trop lourd de renvoyer la texture à chaque modification ?

ça ne doit pas être beaucoup plus lourd que la méthode que tu veux utiliser.
glTexSubImage2D devrait faire ton affaire, je l'utilise pour de la génération de textures procédurales, et ça ne prend quasiment rien, comme temps.