Comment puis-je tester la sortie de rendu unitaire?

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.

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.

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 .

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).