La pile matricielle d'OpenGL vs la multiplication manuelle

Ce qui est plus efficace en utilisant la pile de transformation d'OpenGL ou en appliquant les transformations à la main.

J'ai souvent entendu dire que vous devriez minimiser le nombre de transitions d'état dans votre pipeline graphique. Pousser et faire éclater des matrices de traduction semble être un grand changement. Cependant, je me demande si la carte graphique pourrait plus que compenser le hoquet du pipeline en utilisant son matériel d'exécution parallèle pour multiplier en masse les sommets.

Mon cas spécifique. J'ai rendu la police sur une feuille de sprite. Les coordonnées de chaque caractère ou d'une chaîne sont calculées et ajoutées à un tampon de vertex. Maintenant, je dois déplacer cette chaîne. Serait-il préférable de parcourir le tampon de sommets et d'ajuster chacun des sommets à la main ou de pousser temporairement une nouvelle matrice de traduction?

Je crois comprendre que dans les versions les plus récentes de la spécification (3.3 et 4.x), les piles de matrices ont disparu et vous devez suivre vos matrices de transformation à la main. Je pense que cela pourrait également être vrai pour la spécification mobile (ES).

Si vous cherchez un moyen cohérent de gérer vos matrices à la main, vous pourriez être intéressé par GLM . C'est une bibliothèque mathématique assez soignée (qui inclut des transformations matricielles) modélisée d'après la spécification GLSL, vous n'avez donc qu'à garder un ensemble de routines mathématiques dans votre tête lorsque vous traitez avec du code OpenGL.

La pile est l'option la moins optimale ici - pas parce que la pousser et l'écraser était coûteuse, car elle ne devrait jamais induire un changement d'état complexe au niveau du pilote (la matrice ne devrait pas être envoyée à la carte jusqu'à ce qu'une commande de rendu soit émise , il s'agit donc généralement de manipulations côté processeur dans l'API).

Le problème avec la pile est qu'elle a une limite à quelle distance vous pouvez la pousser - c'est l'un des paramètres que vous pourriez obtenir via glGet * je pense. Il n'y a pas de gros avantage à utiliser la pile, sauf si vous n'avez pas ou êtes incapable / ne souhaitez pas écrire de mathématiques matricielles. Je recommanderais de le faire vous-même.

Je ne sais pas quel est l'état des fonctions de pile dans GL moderne. Je pense qu'ils ont également été dépréciés / supprimés, mais je n'ai pas eu besoin d'utiliser réellement GL depuis un certain temps, donc je ne me suis pas tenu à jour.

Comme d'autres l'ont noté, la pile matricielle est en voie de disparition, ce qui est une bonne raison pour rechercher des alternatives.

Sur l'un de mes projets, j'ai utilisé les opérations matricielles d'OpenGL pour calculer mes matrices, mais j'ai finalement dû utiliser des fonctions glGet pour récupérer la matrice afin de pouvoir effectuer certaines opérations sur la matrice que les propres fonctions d'OpenGL ne prenaient pas en charge. La performance était épouvantable, et j'ai retracé la perte à la fonction glGet unique. Il est possible que les opérations matricielles soient en fait effectuées sur le GPU d'une manière ou d'une autre, et l'utilisation de glGet a provoqué un vidage du pipeline, ou quelque chose du genre.

Quelle que soit la raison, j'ai remplacé les opérations matricielles par CML , la bibliothèque mathématique configurable, et les performances se sont considérablement améliorées. Non seulement je n'étais plus lié aux mesures de performance des opérations de matrice OpenGL, CML comprenait également des tonnes d'opérations que OpenGL ne prend pas en charge.

Et l'implémentation d'une pile de matrices est assez facile en utilisant le vecteur STL ou quelques-uns.

Je ne suis pas sûr de votre niveau d'expérience, mais je recommanderais de le faire à la main. Apprendre à faire cela peut demander plus d'efforts, mais il est extrêmement bénéfique de savoir ce que font vos matrices et de pouvoir les manipuler vous-même. Il vous rendra également plus conscient des problèmes qui peuvent survenir lors de l'application de matrices dans différents ordres (par exemple, mise à l'échelle puis rotation). Je sais que j'ai passé de nombreuses heures à essayer de comprendre des "bugs" de rendu étranges avant de décider que mon temps serait mieux passé à étudier en profondeur ce que chaque opération faisait. Cela vaut l'investissement.

Pour résoudre votre problème spécifique, appliquer une transformation aux sommets semble être le moyen le plus simple, sachez simplement l'ordre des opérations des matrices.

Le principal problème que je vois est que vous devez accéder aux résultats pour d'autres tâches de jeu et accéder à ces résultats peut être compliqué et lent.

C'est pourquoi je préfère faire ces opérations matricielles moi-même.