J'ai actuellement environ 15 passes de rendu dans mon pipeline. Pour chaque passage, je définit les paramètres corrects avant de dessiner et de les réinitialiser ensuite. Ces paramètres incluent la taille de la fenêtre de visualisation, le test de profondeur sur ou la désactivation, la fonction de mélange ou l'éteint, la fonction de pochoir, le fonctionnement de pochoir et plus encore.
Je me demande si OpenGL est assez intelligent pour ignorer les appels API qui définissent un état déjà présent. Parce que, sinon, je garderais une trace de l'état avec beaucoup de drapeaux et avant qu'un passage de rendu ne fixe que l'état s'il est réellement nécessaire.
3 Réponses :
Beaucoup de ceux-ci semblent être des drapeaux, et il serait probablement plus cher de définir un drapeau que de tester et de la définir. Donc, la question serait de savoir si OpenGL est assez stupide pour le faire plutôt que suffisamment intelligent.
Pour le reste, je doute si le coût du calcul, la mise en place peut-être de la matrice de transformation serait significative par rapport au travail de rendu réel, et ne mérite donc pas d'optimiser au niveau de la bibliothèque.
Ne faites pas de telles hypothèses. Sur de nombreuses architectures de mémoire mises en cache, les écrivies inconditionnelles doivent être copiées tout le chemin du retour, mais une lecture / de la comparaison / conditionnelle-conditionnelle peut éviter que le dos coûteux.
La réponse courte: cela dépend du conducteur.
OpenGL elle-même ne fait pas beaucoup de quoi que ce soit. Il appartient aux fournisseurs de mettre en œuvre les fonctions spécifiées par la norme. Est-ce qu'ils testent généralement l'état existant pour éviter de caler inutilement le pipeline? Peut-être que des conseils de lecture de fournisseurs ou de mesurer vous-même, il n'ya aucun moyen de savoir à coup sûr.
Le consensus de l'avis que j'ai vu (aucune référence pour cela, c'est que vous devriez éviter d'appeler OpenGL avec des changements d'état redondants. Cela ne peut pas faire beaucoup de mal et cela pourrait faire du bien.
Dans votre cas (État changeant quelques fois par image entre les passes), cela ne fera probablement pas beaucoup de différence.
Une réponse encore plus courte est la suivante: Non. Au moment où le conducteur tire la commande de sa file d'attente et a donc une chance d'ignorer les appels en double, vous avez déjà fait l'appel de l'API. En outre, l'état de requérant implique généralement de caler le pipeline, ce qui est beaucoup plus cher que de la définir redondante.
@Damon. Le pilote n'a pas à interroger l'état, il pourrait être mis en cache dans une variable facilement. De plus, lorsque nous supposons que les développeurs de pilotes ont mis en œuvre ces tests ou qu'ils n'ont pas de sens, alors dans les deux cas, cela n'a pas de sens que moi de la mettre en œuvre moi-même.
@Danijar: Il n'y a que 2 changements d'état des graphiques qui enlèvent vraiment les performances: commutateurs de texture et commutateurs de shader. On trie généralement par des textures et des shaders avant de rendu, pour cette raison.
@DATENWOLF: Notez bien que cela ne représente que la partie Stalle GPU. Quant aux frais généraux du processeur du pilote, presque tous les changements d'état sont probablement nocifs, même seulement changer le pointeur de base d'un tampon de sommet (comme l'auteur de l'avion X mentionne sur son blog, IIRC). @Danijar: l'état pourrait peut-être être mis en cache (au moins certains), mais ce n'est pas le cas. Sinon, GLGET serait rapide, et ce n'est pas le cas. C'est l'une des fonctions les plus lentes.
@Damon: hmm ... Pensez-vous que je devrais changer "probablement" à "probablement pas" (ou "peut-être" comme un compromis :-)?
Je percevrais que le libellé comme "un peu plus correct", personnellement (car c'est vraiment plutôt non que oui). Cependant, je ne suis pas malheureux de votre réponse de quelque manière que ce soit (en fait, la noté). Ce n'est pas "faux" tel qu'il est, et cela donne le bon avis pratique dans les 2 derniers paragraphes.
@DAMON: Je me demande si vous modifiez immédiatement les effets de pointeur de la base de vap ou si les effets de la perfection des performances ne se produisent que lorsque la première primitive est tirée après le changement de pointeur de base. Si j'étais un développeur de conducteur, je collectionnerais tous les changements d'état jusqu'à ce qu'ils aient effectivement un effet (et que lorsqu'une primitive est tirée), puis calcule uniquement un delta et s'applique qu'à l'état du rendu.
@DATENWOLFF: Je ne trouve pas la référence maintenant, mais à partir de ce que je me souviens, la prise de vue est que la surcharge vient du pilote vérifiant l'objet tampon (et, récursivement, tout le pipeline) pour la validité dès que vous touchez aussi peu que le pointeur de base. Bien que je suis d'accord, en tant qu'écrivain du pilote (ce que je ne suis pas), je les félicite aussi des changements d'État, comme vous le dites. Si c'est toujours possible, qui sait.
@DatenWolf attend la nécessité avant de changer d'État n'a de sens, j'envisage de développer un tel système sur OpenGL pour mon moteur. Mais pour le conducteur, il peut être préférable de changer d'états pendant que le GPU est inactif au lieu d'attendre le lourd travail de dessin.
@Danijar: En raison de la nature asynchrone des changements d'Etat actuels OpenGL sur le GPU peut (et la volonté) sur des moments très différents que les appels sont fabriqués à partir d'un programme client. La mise en œuvre correctement est le plus facile en coalculant tous les états pertinents contre des "points de synchronisation".
Parce que sinon, je garderais une trace de l'état avec beaucoup de drapeaux et avant qu'une passe de rendu ne fixe que l'état s'il est en fait nécessaire.
Veuillez noter que cela pourrait ou pourrait ne pas être plus rapide que de le quitter. OpenGL est, comme d'autre que d'autres, seules une spécification d'API, laissant la mise en œuvre aux fournisseurs de GPU (ou des communautés open source telles que MESA). En général, vous devez vous attendre à ce que chaque appel produise des résultats, mais si votre principale préoccupation est la performance, le seul moyen de choisir vraiment est
profilage . . Ces résultats peuvent varier d'une plate-forme à la plate-forme ou même de la version du pilote graphique, et parfois de telles choses insoupçonnées, telles que l'exécution de la batterie. Jusqu'à ce que vous mesuriez, vous ne pouvez pas dire quel est un problème de performance réel dans votre application.
J'ai demandé une question "similaire" sur des uniformes pour GLSL: Stackoverflow.com/Questtions/14724324/... . La réponse était aussi "cela dépend du conducteur" :)