Рендеринг буфера глубины в OpenGL без шейдеров

У меня есть следующий код C ++ OpenGL, который отображает значения RGB пикселей в сцене:

glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, _windowWidth, _windowHeight);

glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);

glMatrixMode( GL_PROJECTION );
glLoadIdentity();

float aspectRatio = float(_windowWidth) / float(_windowHeight);
gluPerspective(60.0f, aspectRatio, 0.1f, 1000.0f);

glMatrixMode(GL_MODELVIEW);
_camera.Update();
glLoadMatrixf(_camera.Matrix()[0]);

_scene.Render();

glutSwapBuffers();

Однако я хотел бы вместо этого визуализировать буфер глубины сцены, т.е. чтобы значение каждого пикселя было расстоянием по оси Z перед камерой.

То есть в настоящее время я получаю верхнее изображение, но мне нужно нижнее изображение (изображение из здесь):

введите описание изображения здесь

Как мне это сделать? Я не думаю, что использую шейдеры (не так ли?) - и данный совет здесь, похоже, предполагает, что это возможно только с шейдерами.

Также существует этот код, хотя это тоже похоже на использование шейдеров. Насколько сложно будет изменить мой код для использования шейдеров?


c++ opengl depth-buffer
person Bill Cheatham    schedule 17.06.2014    source источник
comment
Я не специалист по графике, но этот шар кажется фонг-блинном, возможно, также обезьяной и кубом ... Я считаю, что вы используете шейдеры, но главный вопрос: как мы можем помочь без кода?   -  person Marco A.    schedule 17.06.2014

Ответы (2)


arrow_upward
6
arrow_downward

Вы можете передать буфер глубины в память хоста через glReadPixels() и GL_DEPTH_COMPONENT и повторно загрузить буфер как GL_LUMINANCE текстуру:

скриншот 

#include <GL/glew.h>
#include <GL/glut.h>

#include <vector>
using namespace std;

void display()
{
    int w = glutGet( GLUT_WINDOW_WIDTH );
    int h = glutGet( GLUT_WINDOW_HEIGHT );

    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    double ar = w / static_cast< double >( h );
    const float zNear = 0.1;
    const float zFar = 10.0;
    gluPerspective( 60, ar, zNear, zFar );

    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();
    glTranslatef( 0, 0, -4 );

    static float angle = 0;
    angle += 3;

    glPushMatrix();
    glRotatef( angle, 0.1, 0.5, 0.3 );
    glColor3ub( 255, 0, 0 );
    glutSolidTeapot( 1 );
    glPopMatrix();

    vector< GLfloat > depth( w * h, 0 );
    glReadPixels( 0, 0, w, h, GL_DEPTH_COMPONENT, GL_FLOAT, &depth[0] ); 

    // linearize depth
    // http://www.geeks3d.com/20091216/geexlab-how-to-visualize-the-depth-buffer-in-glsl/
    for( size_t i = 0; i < depth.size(); ++i )
    {
        depth[i] = ( 2.0 * zNear ) / ( zFar + zNear - depth[i] * ( zFar - zNear ) );
    }

    static GLuint tex = 0;
    if( tex > 0 )
        glDeleteTextures( 1, &tex );
    glGenTextures(1, &tex);
    glBindTexture( GL_TEXTURE_2D, tex);
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
    glTexImage2D( GL_TEXTURE_2D, 0, GL_LUMINANCE, w, h, 0, GL_LUMINANCE, GL_FLOAT, &depth[0] );

    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    glOrtho( 0, w, 0, h, -1, 1 );

    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();

    glEnable( GL_TEXTURE_2D );
    glColor3ub( 255, 255, 255 );
    glScalef( 0.3, 0.3, 1 );
    glBegin( GL_QUADS );
    glTexCoord2i( 0, 0 );
    glVertex2i( 0, 0 );
    glTexCoord2i( 1, 0 );
    glVertex2i( w, 0 );
    glTexCoord2i( 1, 1 );
    glVertex2i( w, h);
    glTexCoord2i( 0, 1 );
    glVertex2i( 0, h );
    glEnd();
    glDisable( GL_TEXTURE_2D );

    glutSwapBuffers();
}

void timer( int value )
{
    glutPostRedisplay();
    glutTimerFunc( 16, timer, 0 );
}

int main( int argc, char **argv )
{
    glutInit( &argc, argv );
    glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE );
    glutInitWindowSize( 600, 600 );
    glutCreateWindow( "GLUT" );
    glewInit();
    glutDisplayFunc( display );
    glutTimerFunc( 0, timer, 0 );
    glEnable( GL_DEPTH_TEST );
    glutMainLoop();
    return 0;
}

Обратное переключение на ЦП не очень быстрое (особенно с линеаризацией на стороне хоста). Вы можете использовать PBO, чтобы выполнить перенос с графического процессора на графический процессор, но вы потеряете линеаризация.

person genpfault    schedule 17.06.2014

arrow_upward
5
arrow_downward

Вы можете использовать объект Framebuffer (fbo) для преобразования значений глубины в текстуру. Затем на втором проходе рендеринга нарисуйте четырехугольник по всему вьюпорту и примените к нему текстуру глубины.

Или вы можете написать фрагментный шейдер, который будет выводить цвета фрагментов в соответствии с их глубиной, это может отображаться за один проход.

См. здесь несколько примеров. Вы можете найти больше поиска по запросу «fbo».

person Archie    schedule 17.06.2014