Проблемы с тестом глубины OpenGL

Только начал заниматься с OpenGL и столкнулся с проблемами с тестом глубины. Использую шейдеры для текстурированного GL_POLYGON и нескольких of GL_LINE_STRIP

void Scene::initializeGL()
{
    glEnable(GL_CULL_FACE);
    /* Enable smooth shading */
    glShadeModel( GL_SMOOTH);
    /* Set the background black */
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glEnable(GL_DEPTH_TEST);
    glDepthMask(GL_TRUE);
    glDepthFunc(GL_LESS);
    m_texture = new QOpenGLTexture( QImage( ":/Textures/Blocks.jpg" ) );
    QOpenGLShader vShader_body( QOpenGLShader::Vertex );
    vShader_body.compileSourceFile( ":/Shaders/vShader_body.glsl" );
    QOpenGLShader fShader_body( QOpenGLShader::Fragment );
    fShader_body.compileSourceFile( ":/Shaders/fShader_body.glsl" );
    m_program_body.addShader( &vShader_body );
    m_program_body.addShader( &fShader_body );
    m_program_body.link();
    m_vertexAttr_body = m_program_body.attributeLocation( "vertex" );
    m_texCoordAttr_body = m_program_body.attributeLocation( "texCoord" );
    m_matrixUniform_body = m_program_body.uniformLocation( "matrix" );
    m_texUniform_body = m_program_body.uniformLocation( "tex" );
    QOpenGLShader vShader_line( QOpenGLShader::Vertex );
    vShader_line.compileSourceFile( ":/Shaders/vShader_line.glsl" );
    QOpenGLShader fShader_line( QOpenGLShader::Fragment );
    fShader_line.compileSourceFile( ":/Shaders/fShader_line.glsl" );
    m_program_line.addShader( &vShader_line );
    m_program_line.addShader( &fShader_line );
    m_program_line.link();
    m_vertexAttr_line = m_program_line.attributeLocation( "vertex" );
    m_texCoordAttr_line = m_program_line.attributeLocation( "texCoord" );
    m_matrixUniform_line = m_program_line.uniformLocation( "matrix" );
    m_texUniform_line = m_program_line.uniformLocation( "tex" );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
}
void Scene::paintGL()
{
    QPainter painter;
    painter.begin( this );
    painter.beginNativePainting();
    glScalef(scale, scale, scale);        
    glRotatef(xRotation, 1.0f, 0.0f, 0.0f); 
    glRotatef(yRotation, 0.0f, 1.0f, 0.0f);
    glRotatef(zRotation, 0.0f, 0.0f, 1.0f);
    glClearColor( 1.0f, 1.0f, 1.0f, 1.0f );
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    glMatrixMode(GL_MODELVIEW); 
    glLoadIdentity();
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
    QMatrix4x4 modelView;
    modelView.perspective( 45.0f, ( GLfloat ) width() / ( GLfloat ) height() , 0.1f, 100.0f );
    modelView.translate( 0.0f, 0.0f, -20.0f );
    modelView.scale( scale );
    modelView.rotate( xRotation, 1.0f, 0.0f, 0.0f );
    modelView.rotate( yRotation, 0.0f, 1.0f, 0.0f );
    modelView.rotate( zRotation, 0.0f, 0.0f, 1.0f );
    if ( !m_program_line.bind() )
        return;
    m_program_line.setUniformValue( m_matrixUniform_line, modelView );
    drawLegs();
    m_program_line.release();
    if ( !m_program_body.bind() )
        return;
    m_program_body.setUniformValue( m_matrixUniform_body, modelView );
    drawBody();
    m_program_body.release();
    painter.endNativePainting();
}
void Scene::drawBody()
{
    m_texture->bind();
    m_program_body.setAttributeArray( m_vertexAttr_body, m_body.vertices.data(), 3 );
    m_program_body.setAttributeArray( m_texCoordAttr_body, m_body.texCoords.data(), 2 );
    m_program_body.setUniformValue( m_texUniform_body, 0 );
    m_program_body.enableAttributeArray( m_vertexAttr_body );
    m_program_body.enableAttributeArray( m_texCoordAttr_body );
    glDrawArrays( GL_POLYGON, 0, 6 );
    m_program_body.disableAttributeArray( m_vertexAttr_body );
    m_program_body.disableAttributeArray( m_texCoordAttr_body );
}
void Scene::drawLegs()
{
    Hexapod_legs hexapod;
    Hexapod_legs::_point point[6];
    point[0].x =  0.59f;
    point[0].y =  1.11f;
    point[0].z =  0.80f;
    point[1].x =  0.91f;
    point[1].y =  0.00f;
    point[1].z =  0.80f;
    point[2].x =  0.59f;
    point[2].y = -1.11f;
    point[2].z =  0.80f;
    point[3].x = -0.59;
    point[3].y = -1.11;
    point[3].z =  0.80;
    point[4].x = -0.91;
    point[4].y =  0.00;
    point[4].z =  0.80;
    point[5].x = -0.59;
    point[5].y =  1.11;
    point[5].z =  0.80;
    Hexapod_legs::_speed speed;
    speed.spd_x = 10;
    speed.spd_y = 0;
    speed.spd_r = 0;
    m_texture->bind();
    std::vector<float> legs;
    m_program_body.enableAttributeArray( m_vertexAttr_line );
    m_program_body.enableAttributeArray( m_texCoordAttr_line );
    m_program_body.setUniformValue( m_texUniform_line, 0 );
    for(int i = 0; i < 2; i ++)
    {
        legs = hexapod.plot_leg(point[i], i, speed, 5, 10);
        m_program_body.setAttributeArray( m_vertexAttr_line, legs.data(), 3);
        glLineWidth(40);
        glDrawArrays( GL_LINE_STRIP, 0, 4 );
    }
    m_program_body.disableAttributeArray( m_vertexAttr_line );
    m_program_body.disableAttributeArray( m_texCoordAttr_line );
}

Шейдеры элементарные:

//fShader_body.glsl
varying highp vec4 texc;
uniform sampler2D tex;
void main( void )
{
    highp vec3 color = texture2D( tex, texc.st ).rgb;
    color = color * 0.2 + color * 0.8;
    gl_FragColor = vec4( clamp( color, 0.0, 1.0 ), 1.0 );
    //gl_FragColor = vec4(gl_FragCoord.z);
}

//fShader_line.glsl
void main( void )
{
    gl_FragColor = vec4( 0.345f, 0.468f, 0.976f, 1.0 );
    //gl_FragColor = vec4(gl_FragCoord.z);
}

//vShader_body.glsl
attribute highp vec4 vertex;
attribute highp vec4 texCoord;
uniform mediump mat4 matrix;
varying highp vec4 texc;
void main( void )
{
    gl_Position = matrix * vertex;
    texc = texCoord;
}

//vShader_line.glsl
attribute highp vec4 vertex;
uniform mediump mat4 matrix;
void main( void )
{
    gl_Position = matrix * vertex;
}

Положения вершин рассчитываются в не приведенном коде, но с ними проблем нет. При рендеринге я вижу объекты (линии и полигон) в порядке рисования, а не в порядке глубины. Почему?