Obtendo uma textura de um renderbuffer no OpenGL?

Eu tenho um renderbuffer (DepthStencil) em um FBO e preciso obter uma textura dele. Parece que não posso ter uma textura DepthComponent e um depthStencil no FBO, por isso preciso de alguma maneira de converter o bufferbase em uma textura DepthComponent depois de terminar o uso para usá-lo posteriormente no pipeline.

Tentei várias técnicas para pegar o componente de profundidade do renderbuffer por semanas, mas sempre saio com lixo. Tudo o que quero no final é a mesma textura que receberia de um FBO se não estivesse usando um buffer de renderização. Alguém pode postar algumas instruções abrangentes ou código que cubra essa operação aparentemente simples?

EDITAR:

Linky para uma versão extraída do código http://dl.dropbox.com/u/9279501/fbo.cs

Screeny do efeito Profundidade de Campo + FBO - sem profundidade (!) Http://i.stack.imgur.com/Hj9Oe.jpg

Screeny sem efeito de profundidade de campo + FBO - profundidade funcionando bem http://i.stack.imgur.com/boOm1.jpg

Como alternativa, você pode escolher entre um FBO e outro, como um baseado em buffer de renderização e outro baseado em textura. Eu faço assim:

glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_renderBufferSurface->m_fbo);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_textureSurface->m_fbo);
glBlitFramebufferEXT(0, 0, m_renderBufferSurface->m_width, m_renderBufferSurface->m_height, 0, 0, m_textureSurface->m_width, m_textureSurface->m_height, GL_COLOR_BUFFER_BIT, GL_NEAREST);

(No seu caso, onde você deseja aprofundar o buffer, você pode usar GL_DEPTH_BUFFER_BIT em vez de GL_COLOR_BUFFER_BIT)

Após selecionar o buffer de renderização baseado em textura, você poderá usar a textura normalmente; passando para shaders como uniforme ou o que você quiser.

Não, isso não é possível. No máximo, você pode glReadPixels os dados para a CPU e criar uma textura deles, mas isso será complicado e lento. Renderbuffers não são para isso, essa funcionalidade é fornecida apenas por texturas.

O que você está perguntando é possível no OpenGL 3.2. Eu tenho meu FBO exibindo cores difusas em uma textura de cor, normais em outra textura de cor e profundidade em uma textura de profundidade - não são necessários amortecedores de renderização. De fato, os buffers de renderização são apenas um problema, porque você não pode obter amostras deles; portanto, você teria que usar glReadPixels(...)ou copiar de alguma forma os dados da RBO para uma textura na CPU, em vez de apenas manter tudo na memória da GPU. Então...

Se você realmente quiser, pode escrever um código no seu sombreador de primeira passagem para enviar manualmente coisas como profundidade, para um anexo de textura de cor separado no seu FBO. Isso seria para você usar em seus shaders pós-passe. Para o uso do OpenGL em seus testes internos de profundidade, você precisaria adicionalmente de uma RBO ou textura definida como GL_DEPTH_ATTACHMENT do seu FBO. Mas você pode configurar uma única textura para servir a ambos - isso é mais eficiente e fácil de usar.

Meu código de configuração de textura de profundidade se parece com isso (Java, apenas ignore o material ByteBuffer ... e observe que eu uso "id" para me referir a identificadores / ponteiros inteiros, já que esse conceito realmente não se encaixa bem em Java):

        gBufferDepthTexture = new Texture();
        gBufferDepthTexture.id = glGenTextures();
        gBufferDepthTexture.unit = 2;
        gBufferDepthTexture.width = Display.getWidth();
        gBufferDepthTexture.height = Display.getHeight();
        gBufferDepthTexture.bytes = ByteBuffer.allocateDirect(Display.getWidth()*Display.getHeight() * 4);
        glActiveTexture(gBufferDepthTexture.unit + GL_TEXTURE0); //eg. 0 + 33984 = GL_TEXTURE0, while 31 + 33984 = GL_TEXTURE31.
        glBindTexture(GL_TEXTURE_2D, gBufferDepthTexture.id);

        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, gBufferDepthTexture.width, gBufferDepthTexture.height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, gBufferDepthTexture.bytes);
        //...GL_UNSIGNED_INT or GL_UNSIGNED_BYTE may work better for you, instead... YMMV.

        //glPixelStorei(GL_PACK_ALIGNMENT, 4);
        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

E depois:

        glBindFrameBuffer(GL_DRAW_FRAMEBUFFER, fbo.id);
        //your existing glFramebufferTexture2D(...) calls here
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, gBufferDepthTexture.id, 0);

Agora você pode passar gBufferDepthTexture(ou o que você tem) como um uniforme para o seu segundo e terceiro pass shaders de fragmento. Acho que podemos assumir com segurança que você pode fazer exatamente a mesma coisa com o buffer de estêncil.

Você deve conseguir criar uma textura (em vez de um RenderBuffer) usando o formato GL_DEPTH_STENCIL. Não tenho certeza do processo exato para usar a profundidade de tal textura em um programa de sombreador (que suponho que você esteja usando, já que usa FBOs), mas a especificação do OpenGL deve especificar quais canais de cores obtêm quais valores ( meu palpite seria que R, G e B são todos ajustados à profundidade e A é definido como estêncil).

Atualmente, tenho como alvo o OpenGL 3.2, portanto, talvez seja necessário verificar se o formato da textura é viável para você. Nunca me lembro quais versões introduzem recursos diferentes.