Oculus fail code

void paintGL()
{
    paint_to_frameBuffer();
    paint_to_display();
}

void paint_to_frameBuffer()
{
    glPushAttrib( GL_TEXTURE_BIT | GL_DEPTH_TEST | GL_LIGHTING );

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING);
    glEnable(GL_CULL_FACE);

    // Render to our framebuffer
    glBindFramebuffer(GL_FRAMEBUFFER, gl_frame_buffer);

    // Render to screen (for debugging)
    //    glBindFramebuffer(GL_FRAMEBUFFER, 0);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // draw left viewpoint
    setUpCamera(OVR::Util::Render::StereoEye_Left);
    drawEverything();
    // draw right viewpoint
    setUpCamera(OVR::Util::Render::StereoEye_Right);
    drawEverything();

    glPopAttrib();
}

void setUpCamera(OVR::Util::Render::StereoEye eye)
{
    const OVR::HMDInfo& hmd = m_HMD_info;
    const OVR::Util::Render::StereoEyeParams& params = m_stereo_config.GetEyeRenderParams(eye);
    glViewport(params.VP.x, params.VP.y/*+1152-params.VP.h*/, params.VP.w, params.VP.h);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    applyGLMatrix(params.ViewAdjust);
    applyGLMatrix(params.Projection);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    OVR::Matrix4f eye_view = get_eye_view(eye);
    applyGLMatrix(eye_view);
}

void paint_to_display()
{
    glPushAttrib(GL_TEXTURE_BIT | GL_DEPTH_TEST | GL_LIGHTING );

    glDisable(GL_CULL_FACE);
    glDisable(GL_DEPTH_TEST);
    glDisable(GL_LIGHTING);
    glEnable(GL_TEXTURE_2D);

    // Render to the screen
    glBindFramebuffer(GL_FRAMEBUFFER, 0);

    // reset the screen params.
    glViewport(0, 0, this->width(), this->height() );
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glUseProgram(gl_fragment_shader_program);

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, gl_frame_buffer_texture);

    gl_uniform_1i("texture0", 0);

    renderEyePatch(OVR::Util::Render::StereoEye_Right);
    renderEyePatch(OVR::Util::Render::StereoEye_Left);

    glBindTexture(GL_TEXTURE_2D, 0);
    glUseProgram(0);
    glPopAttrib();
}

void renderEyePatch(OVR::Util::Render::StereoEye eye)
{
        // apply distortion for each eye.
        const OVR::Util::Render::StereoEyeParams& params = m_stereo_config.GetEyeRenderParams(eye);
        if(params.pDistortion)
        {
                GLsizei width = m_HMD_info.HResolution;
                GLsizei height = m_HMD_info.VResolution;
                const OVR::Util::Render::DistortionConfig& distortion = *params.pDistortion;

                float w  = float(params.VP.w) / float(width),
                          h  = float(params.VP.h) / float(height),
                          x  = float(params.VP.x) / float(width),
                          y  = float(params.VP.y) / float(height);
                float as = float(params.VP.w) / float(params.VP.h);

                // We are using 1/4 of DistortionCenter offset value here, since it is
                // relative to [-1,1] range that gets mapped to [0, 0.5].
                float HmdWarpParam[4]   = { distortion.K[0], distortion.K[1], distortion.K[2], distortion.K[3] };
                float ChromAbParam[4]   = { distortion.ChromaticAberration[0], distortion.ChromaticAberration[1], distortion.ChromaticAberration[2], distortion.ChromaticAberration[3] };
                float scaleFactor       = 1.0f / distortion.Scale;
                OVR::Vector2f LensCenter    (x + (w + distortion.XCenterOffset * 0.5f)*0.5f, y + h*0.5f);
                if(eye == OVR::Util::Render::StereoEye_Right)
                    LensCenter.x = x + (w - distortion.XCenterOffset * 0.5f)*0.5f;
                OVR::Vector2f ScreenCenter  (x + w*0.5f ,y + h*0.5f);
                OVR::Vector2f Scale         ((w/2) * scaleFactor, (h/2) * scaleFactor * as);
                OVR::Vector2f ScaleIn       ((2/w), (2/h) / as);

                // fragment shader.
                gl_uniform_2f("LensCenter", LensCenter.x, LensCenter.y); qDebug() << "Lenscenter x y:" << LensCenter.x << LensCenter.y;
                gl_uniform_2f("ScreenCenter", ScreenCenter.x, ScreenCenter.y);
                gl_uniform_2f("Scale", Scale.x, Scale.y);
                gl_uniform_2f("ScaleIn", ScaleIn.x, ScaleIn.y);
                gl_uniform_4f("HmdWarpParam", HmdWarpParam[0], HmdWarpParam[1], HmdWarpParam[2], HmdWarpParam[3]);
                gl_uniform_4f("ChromAbParam", ChromAbParam[0], ChromAbParam[1], ChromAbParam[2], ChromAbParam[3]);
        }

        // render the quad on display.
        switch(eye)
        {
        case OVR::Util::Render::StereoEye_Left:
            glBindBuffer(GL_ARRAY_BUFFER, m_vertex_buffer_eye_1);
            glEnableVertexAttribArray(0);
            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);

            glBindBuffer(GL_ARRAY_BUFFER, m_uv_buffer_eye_1);
            glEnableVertexAttribArray(1);
            glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);

            glDrawArrays(GL_QUADS, 0, 4);

            glBindBuffer(GL_ARRAY_BUFFER, 0);
            glEnableVertexAttribArray(0);
            glEnableVertexAttribArray(1);
            break;
        case OVR::Util::Render::StereoEye_Right:
            glBindBuffer(GL_ARRAY_BUFFER, m_vertex_buffer_eye_2);
            glEnableVertexAttribArray(0);
            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);

            glBindBuffer(GL_ARRAY_BUFFER, m_uv_buffer_eye_2);
            glEnableVertexAttribArray(1);
            glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);

            glDrawArrays(GL_QUADS, 0, 4);

            glBindBuffer(GL_ARRAY_BUFFER, 0);
            glEnableVertexAttribArray(0);
            glEnableVertexAttribArray(1);
            break;
        default:
            break;
        }
}