Recientemente he estado adoptando el desarrollo basado en pruebas (TDD) y ha tenido un impacto maravilloso en mi producción de desarrollo y la resistencia de mi base de código. Me gustaría extender este enfoque a algunos de los trabajos de renderizado que hago en OpenGL, pero no he podido encontrar ningún buen enfoque para esto.
Comenzaré con un ejemplo concreto para que sepamos qué tipo de cosas quiero probar; Digamos que quiero crear un cubo unitario que gire alrededor de algún eje, y que quiero asegurarme de que, para una cierta cantidad de cuadros, cada cuadro se represente correctamente.
¿Cómo puedo crear un caso de prueba automatizado para esto? Preferiblemente, incluso podría escribir un caso de prueba antes de escribir cualquier código para renderizar el cubo (según las prácticas habituales de TDD). Entre muchas otras cosas, me gustaría asegurarme de que el tamaño, la ubicación y la orientación del cubo sean correcto en cada cuadro renderizado. Incluso puedo asegurarme de que las ecuaciones de iluminación en mis sombreadores sean correctas en cada cuadro.
El único enfoque remotamente útil para esto que he encontrado implica comparar la salida renderizada con una salida de referencia, lo que generalmente impide la práctica de TDD, y es muy engorroso.
Podría continuar con otros requisitos deseados, pero me temo que los que he enumerado ya están fuera de mi alcance.
Respuestas:
Esto parece una buena aplicación del marco de pruebas de aprobación o algo similar.
Como se indicó en los comentarios, todavía tendrá un problema con los falsos positivos, si aprueba una salida incorrecta, pero al menos esto le indicará cuándo la salida ha cambiado significativamente.
Dado que está utilizando OpenGL, supongo que las aprobaciones no funcionarán para usted directamente, pero la idea es sólida. Simplemente verifique el hash del archivo y, si es diferente, muestre el error en un visor de diferencias apropiado (como un programa de diferencias de imagen). Si aprueba la nueva versión, actualice el archivo "aprobado" para que coincida con el nuevo resultado.
fuente
No estoy en el negocio de los juegos, así que por favor tenga una percepción estúpida e ingenua
Para mí, escribir pruebas que comparen imágenes totalmente renderizadas no son realmente pruebas unitarias , sino pruebas de integración completa , porque todo tiene que funcionar bien para una ejecución de prueba exitosa.
¿Qué pasa con una capa intermedia donde puedes comprobar que todo está bien? Hay dos cosas que me vienen a la mente:
No dibuje directamente, pero emita una secuencia de comandos que se convierta en renderizar llamadas en el camino. La secuencia de comandos se puede verificar para su corrección. Esta no es una prueba de extremo a extremo, pero desea pruebas unitarias , no pruebas de integración completa.
Esto es realmente una variación de 1. Ajuste OpenGL, capture todas las llamadas, reduzca esto a lo que realmente desea probar y compruebe si la salida aún coincide. El contenedor OpenGL puede hacer la comprobación por sí mismo si está configurado correctamente, y se convierte en una simulación .
fuente
El problema es que no se requieren motores 3D para generar una imagen exacta bit por bit. Se tolera cierto margen de maniobra siempre que los artefactos causados por él no sean visibles para el espectador. Una textura que es 1% más oscura de lo esperado generalmente no es un problema grave ... por lo general. En algunas condiciones, puede ser un artefacto visual. Y ese es el problema: es difícil juzgar por una prueba automatizada qué artefactos serían notados por un espectador humano y cuáles no. Aún así, las pruebas automatizadas pueden usarse para verificaciones de cordura simples cuando se usan en geometría muy simple.
Lo que podría hacer es renderizar algunas escenas simples y luego comparar la imagen generada con una representación de referencia. Esa representación de referencia podría provenir de otro motor gráfico o ser una captura de pantalla anterior del mismo motor (prueba de regresión).
Cuando algunas pruebas fallan después de un cambio en el motor gráfico, un probador humano debe comparar la salida con la imagen de referencia y juzgar por sí mismo si la nueva salida se ve tan bien como antes (o incluso mejor). Cuando ese sea el caso, la prueba debe cambiarse para compararla con las salidas nuevas y mejoradas.
Otra cosa que puede verificar automáticamente son los requisitos de rendimiento. Uno de esos requisitos podría ser que durante una demostración de ejecución automática (simulando una secuencia real del juego) la velocidad de fotogramas no debe caer por debajo de 40 Fps en el sistema de prueba. Esto es algo que puedes probar automáticamente. Lo que no puede probar es que el renderizado es satisfactorio. Pero puede usar tales pruebas para evitar que sus desarrolladores desarrollen un juego que se vea excelente pero que no se ejecute correctamente en ningún sistema asequible hasta años después del lanzamiento (hola Crytek).
fuente