Depurando código de sombreador?

Estou escrevendo um mecanismo de jogo e, quando uso uma câmera em perspectiva, recebo uma tela preta. Não vou perguntar exatamente por que isso ocorre, porque haveria muito código para compartilhar e, francamente, acho que é uma pergunta um pouco mesquinha mesmo para incomodá-los.

O problema é que eu não sei como depurá-lo. Tudo o que muda é a minha matriz de projeção, e se minha matriz de projeção parece boa, não sei por que não funciona. Idealmente, eu imprimia os valores de várias coisas como o shader fazia seus cálculos, mas o GLSL inconvenientemente não possui uma função printf ().

Então, minha pergunta é: como depurar meu problema? A única coisa em que consigo pensar é verificar o maior número possível de valores no lado do cliente e depois programar por permutação, mas fiz isso e não cheguei a lugar algum. Existe uma maneira de ver o que está acontecendo na placa de vídeo? Existe uma técnica completamente diferente que eu poderia estar usando?

Estou usando o GLSL versão 420 (e recursos específicos para essa versão), por isso não acho que o glslDevil seja uma opção, considerando que ele foi atualizado pela última vez em 2010.

EDITAR

Consegui resolver meu problema através de uma depuração completamente não relacionada.

Você também pode usar um programa como o glIntercept, que é como o PIX, mas depois para o OpenGL. Além de interceptar e registrar todas as chamadas, também é possível exibir o uso do shader e editar os shaders no tempo de execução. Essa última opção (editar os sombreadores em tempo de execução) pode ser extremamente útil ao depurar, porque você pode continuar editando partes até que algo dê errado e depurar rapidamente um valor produzindo uma cor.

http://code.google.com/p/glintercept/

Embora eu não tenha certeza, o NVIDIA Nsight deve ser capaz de depurar Shaders, pelo menos acho que ele suportava o GLSL em alguma versão anterior (que você deve encontrar). Ele se integra bastante bem ao Visual Studio, não é fácil, mas possui muitas coisas úteis, mas nas versões anteriores você precisava de 2 máquinas com uma GPU para depurar shaders por uma rede (enquanto a versão mais recente diz que permite a depuração "local") . Além disso, verifique o Shader Designer [2], que parece ser um IDE útil (mas sem depuração do GLSL).

[1] http://developer.nvidia.com/content/nvidia-nsight-visual-studio-edition

[2] http://www.opengl.org/sdk/tools/ShaderDesigner/

Infelizmente, depurar o opengl não é fácil. Aqui estão as coisas que eu achei úteis:

• use glGetError após cada chamada
• tente usar a nova extensão de depuração (ARB_debug _ ???)
• use o gDebugger para ver o que é desenhado na tela após cada chamada
• use apitrace para ver o que acontece após cada comando opengl
• modifique seu shader para produzir cores diferentes com base na entrada atual e tente entender por que mostra uma determinada cor
• desative todas as funcionalidades do OpenGL que limitem os recursos de desenho: teste de tesoura, teste de profundidade, seleção da face posterior etc.

Pessoalmente, ainda uso o RenderMonkey. No entanto, não é totalmente adequado para essa pergunta exata, porque é apenas uma fachada de um aplicativo real e, portanto, tem algumas limitações estranhas. Está bem sem suporte, mas não encontrei nada melhor para depurar o GLSL.