Comment puis-je tester la sortie de rendu unitaire?

19

J'ai récemment adopté le développement piloté par les tests (TDD) et cela a eu de merveilleux impacts sur ma sortie de développement et la résilience de ma base de code. Je voudrais étendre cette approche à certains des travaux de rendu que je fais dans OpenGL, mais je n'ai pas pu trouver de bonnes approches à ce sujet.

Je vais commencer par un exemple concret afin que nous sachions quels types de choses je veux tester; disons que je veux créer un cube unitaire qui tourne autour d'un axe et que je veux m'assurer que, pour un certain nombre d'images, chaque image est rendue correctement.

Comment puis-je créer un scénario de test automatisé pour cela? De préférence, je serais même capable d'écrire un scénario de test avant d'écrire du code pour rendre le cube (selon les pratiques TDD habituelles). Entre autres choses, je voudrais m'assurer que la taille, l'emplacement et l'orientation du cube sont correct dans chaque image rendue. Je peux même vouloir m'assurer que les équations d'éclairage dans mes shaders sont correctes dans chaque image.

La seule approche à distance utile à ce sujet que j'ai rencontrée consiste à comparer la sortie rendue à une sortie de référence, ce qui empêche généralement la pratique TDD et est très encombrant.

Je pourrais continuer sur d'autres exigences souhaitées, mais je crains que celles que j'ai déjà énumérées soient hors de portée.

notlesh
la source
3
Tout le problème ici est que votre cas de test est déterminé par une bonne sortie; mais que se passe-t-il si cette sortie est buggée (faux positif)? Dans tous les cas, je commencerais par vérifier d'abord les wireframes; passez ensuite à une scène de rendu avant et finalement différée (si vous l'utilisez). Vous pouvez XOR l'image entière pour faire une comparaison rapide (passes entièrement noires). Le GPU est vraiment un mauvais domaine pour appliquer TDD; mais si vous venez avec quelque chose d'intelligent, j'aimerais savoir.
Jonathan Dickinson
Je soupçonne que je n'obtiendrai pas exactement la réponse que j'espère, mais j'espère toujours de bonnes idées. Bonne pensée sur le col noir. Tester le tampon de profondeur pourrait également être utile.
notlesh
@Adam merci d'avoir partagé cela. Malheureusement, il est ainsi hors de portée pour un indie comme moi travaillant sur les jeux mobiles :) Elle ne tient pas la plupart de mes exigences de base.
2012
@Adam, vous devez absolument «répondre» à ce lien. Tout à fait nouveau.
Jonathan Dickinson

Réponses:

8

Cela semble être une bonne application du cadre des tests d'approbation ou quelque chose comme ça.

Comme indiqué dans les commentaires, vous aurez toujours un problème de faux positifs, si vous approuvez une mauvaise sortie, mais cela vous indiquera au moins quand la sortie a changé de manière significative.

Puisque vous utilisez OpenGL, je suppose que les approbations ne fonctionneront pas directement pour vous, mais l'idée est bonne. Vérifiez simplement le hachage du fichier et s'il est différent, montrez l'échec dans un visualiseur de diff approprié (comme un programme de diff d'image). Si vous approuvez la nouvelle version, mettez à jour le fichier "approuvé" pour qu'il corresponde au nouveau résultat.

John Gietzen
la source
Voilà un outil intéressant. Si vous preniez quelque chose comme la batterie de tests dans le lien d'Adam dans les commentaires ci-dessus, et appliquiez un mécanisme d'approbation intégré comme celui-ci, vous commenceriez probablement à aborder quelque chose qui est assez faible. Merci d'avoir partagé!
notlesh
Le test d'approbation n'est pas un test automatisé.
zwcloud
@zwcloud: Que voulez-vous dire? Il est automatisé une fois créé, comme tout test. C'est juste que la première approbation fait partie du processus de création.
John Gietzen
@JohnGietzen Je n'ai pas compris cela d'après votre réponse. Je pense que vous devriez clarifier plus clairement l'idée des tests d'approbation . Je supprimerai le downvote lorsque la réponse sera mise à jour.
zwcloud
6

Je ne suis pas dans le domaine du jeu, alors supportez toute perception stupide et naïve potentielle

Pour moi, écrire des tests qui comparent des images entièrement rendues ne sont pas vraiment des tests unitaires , mais des tests d' intégration complets, car tout doit fonctionner correctement pour un test réussi.

Qu'en est-il d'une couche intermédiaire où vous pouvez vérifier que tout va bien? Il y a deux choses qui me viennent à l'esprit:

  1. Ne dessinez pas directement, mais émettez un flux de commandes qui se transforme en rendu d'appels en cours de route. L'exactitude du flux de commandes peut être vérifiée. Ce n'est pas un test de bout en bout, mais vous voulez des tests unitaires , pas des tests d'intégration complète.

  2. C'est vraiment une variation sur 1. Enveloppez OpenGL, interceptez tous les appels, supprimez-le jusqu'à ce que vous voulez vraiment tester et vérifiez si la sortie correspond toujours. L'encapsuleur OpenGL peut effectuer la vérification lui-même s'il est correctement configuré et se transforme en maquette .

Stefan Hanke
la source
3

Le problème est que les moteurs 3D ne sont pas nécessaires pour produire une image exacte bit par bit. Une certaine latitude est tolérée tant que les artefacts causés par celle-ci ne sont pas visibles pour le spectateur. Une texture étant 1% plus sombre que prévu n'est généralement pas un problème grave ... généralement. Dans certaines conditions, il peut s'agir d'un artefact visuel. Et c'est le problème: il est difficile de juger pour un test automatisé quels artefacts seraient remarqués par un spectateur humain et lesquels ne le seraient pas. Pourtant, les tests automatisés peuvent être utilisés pour de simples vérifications de santé mentale lorsqu'ils sont utilisés sur une géométrie très simple.

Ce que vous pourriez faire, c'est rendre quelques scènes simples, puis comparer l'image générée avec un rendu de référence. Ce rendu de référence peut provenir d'un autre moteur graphique ou être une capture d'écran antérieure du même moteur (test de régression).

Lorsque certains tests échouent après une modification du moteur graphique, un testeur humain doit comparer la sortie à l'image de référence et juger par lui-même si la nouvelle sortie semble aussi bonne qu'auparavant (ou même mieux). Dans ce cas, le test doit être modifié pour être comparé aux nouvelles sorties améliorées.

Vous pouvez également vérifier automatiquement les exigences de performances. Une telle exigence pourrait être que lors d'une démo auto-exécutée (simulant une séquence réelle du jeu), la fréquence d'images ne doit pas descendre en dessous de 40 Fps sur le système de test. C'est quelque chose que vous pouvez tester automatiquement. Ce que vous ne pouvez pas tester, c'est que le rendu est satisfaisant. Mais vous pouvez utiliser de tels tests pour empêcher vos développeurs de développer un jeu qui a l'air superbe mais qui ne fonctionne correctement sur aucun système abordable avant des années après le lancement (bonjour Crytek).

Philipp
la source