Fixing various issues that were showing up when trying to snapshot/restore Cube 2:

- RBO's which have been genned but never initialized are now properly snapshotted/restored
- Adding support for GL_FLOAT_RG16_NV
- Fixing size of XVisualInfo struct's ctype desc so the --find command doesn't trigger a harmless but annoying assert in 32-bit builds while scanning through 64-bit traces
- Misc help text fixes

diff --git a/src/voglcommon/vogl_ctypes.cpp b/src/voglcommon/vogl_ctypes.cpp
index ee81b1ae8442c4e8551346ca42b3d7fb62948290..714a8853f6415283f4d9af0f4f6f3d0dfb7b3e75 100644 (file)
--- a/src/voglcommon/vogl_ctypes.cpp
+++ b/src/voglcommon/vogl_ctypes.cpp
@@ -145,6 +145,10 @@ void vogl_ctypes::change_pointer_sizes(uint trace_ptr_size)
 //DEF_LONG_TYPE(VOGL_CURSOR);
 #undef DEF_LONG_TYPE
 
+    // Special case the XVisualInfo struct because its size differs between 32-bit and 64-bit - argh this sucks and we need a MUCH cleaner way of handling this.
+    // In practice this only fixes an assertion, because the packets always describe the exact length of objects.
+    m_vogl_ctype_descs[VOGL_XVISUALINFO].m_size = (trace_ptr_size == 8) ? 64 : 40;
+
 #if 1
     // sanity check
     for (uint ctype_iter = 0; ctype_iter < VOGL_NUM_CTYPES; ctype_iter++)

diff --git a/src/voglcommon/vogl_internal_texture_formats.inc b/src/voglcommon/vogl_internal_texture_formats.inc
index 1459772c86906bb768deea7363fc50f21a5e02d9..31de1b927ac69e6028bdb3b51542d186d8c4e883 100644 (file)
--- a/src/voglcommon/vogl_internal_texture_formats.inc
+++ b/src/voglcommon/vogl_internal_texture_formats.inc
@@ -273,6 +273,11 @@ vogl_internal_tex_format(0x0001, "GL_ONE", 0x0001,
                             GL_FLOAT, GL_FLOAT, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE,
                             0, 0x1F, 0,
                             GL_RG, GL_HALF_FLOAT, 4, 0, 0),
+    vogl_internal_tex_format(0x8886, "GL_FLOAT_RG16_NV", 0x8886,
+                            16, 16, 0, 0, 0, 0, 0, 0,
+                            GL_FLOAT, GL_FLOAT, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE,
+                            0, 0x1F, 0,
+                            GL_RG, GL_HALF_FLOAT, 4, 0, 0),
     vogl_internal_tex_format(0x8230, "GL_RG32F", 0x8230,
                             32, 32, 0, 0, 0, 0, 0, 0,
                             GL_FLOAT, GL_FLOAT, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE,

diff --git a/src/voglcommon/vogl_renderbuffer_state.cpp b/src/voglcommon/vogl_renderbuffer_state.cpp
index 708e4df827c4adbcbcb189ca851c63908f12814c..a5f0c2e644dd1e9ff0db620ffab42b30177aa41c 100644 (file)
--- a/src/voglcommon/vogl_renderbuffer_state.cpp
+++ b/src/voglcommon/vogl_renderbuffer_state.cpp
@@ -293,149 +293,157 @@ bool vogl_renderbuffer_state::snapshot(const vogl_context_info &context_info, vo
     if (!m_desc.snapshot(context_info))
         return false;
 
-    vogl_scoped_state_saver framebuffer_state_saver(cGSTReadBuffer, cGSTDrawBuffer);
-    vogl_scoped_binding_state orig_framebuffers(GL_DRAW_FRAMEBUFFER, GL_READ_FRAMEBUFFER, GL_TEXTURE_2D, GL_TEXTURE_2D_MULTISAMPLE);
-
-    const GLenum tex_target = (m_desc.m_samples > 1) ? GL_TEXTURE_2D_MULTISAMPLE : GL_TEXTURE_2D;
-
-    bool capture_status = false;
-
-    GLenum internal_fmt = m_desc.m_internal_format;
-    const vogl_internal_tex_format *pInternal_tex_fmt = vogl_find_internal_texture_format(internal_fmt);
-    if ((pInternal_tex_fmt) && (pInternal_tex_fmt->m_optimum_get_image_fmt != GL_NONE) && (pInternal_tex_fmt->m_optimum_get_image_type != GL_NONE))
+    if ((!m_desc.m_width) || (!m_desc.m_height) || (!m_desc.m_internal_format))
     {
-        // Create texture
-        GLuint tex_handle = 0;
-        GL_ENTRYPOINT(glGenTextures)(1, &tex_handle);
-        VOGL_CHECK_GL_ERROR;
+        // Renderbuffer was only genned - no need to spit out warning
+        //vogl_warning_printf("%s: Unable to retrieve description renderbuffer %" PRIu64 "\n", VOGL_METHOD_NAME, static_cast<uint64_t>(handle));
+    }
+    else
+    {
+        vogl_scoped_state_saver framebuffer_state_saver(cGSTReadBuffer, cGSTDrawBuffer);
+        vogl_scoped_binding_state orig_framebuffers(GL_DRAW_FRAMEBUFFER, GL_READ_FRAMEBUFFER, GL_TEXTURE_2D, GL_TEXTURE_2D_MULTISAMPLE);
 
-        GL_ENTRYPOINT(glBindTexture)(tex_target, tex_handle);
-        VOGL_CHECK_GL_ERROR;
+        const GLenum tex_target = (m_desc.m_samples > 1) ? GL_TEXTURE_2D_MULTISAMPLE : GL_TEXTURE_2D;
 
-        if (m_desc.m_samples > 1)
-        {
-            GL_ENTRYPOINT(glTexImage2DMultisample)(tex_target,
-                m_desc.m_samples,
-                internal_fmt,
-                m_desc.m_width,
-                m_desc.m_height,
-                GL_TRUE);
-        }
-        else
-        {
-            GL_ENTRYPOINT(glTexImage2D)(tex_target,
-                0,
-                internal_fmt,
-                m_desc.m_width,
-                m_desc.m_height,
-                0,
-                pInternal_tex_fmt->m_optimum_get_image_fmt,
-                pInternal_tex_fmt->m_optimum_get_image_type,
-                NULL);
-        }
+        bool capture_status = false;
 
-        if (!vogl_check_gl_error_internal())
+        GLenum internal_fmt = m_desc.m_internal_format;
+        const vogl_internal_tex_format *pInternal_tex_fmt = vogl_find_internal_texture_format(internal_fmt);
+        if ((pInternal_tex_fmt) && (pInternal_tex_fmt->m_optimum_get_image_fmt != GL_NONE) && (pInternal_tex_fmt->m_optimum_get_image_type != GL_NONE))
         {
-            GL_ENTRYPOINT(glTexParameteri)(tex_target, GL_TEXTURE_MAX_LEVEL, 0);
+            // Create texture
+            GLuint tex_handle = 0;
+            GL_ENTRYPOINT(glGenTextures)(1, &tex_handle);
             VOGL_CHECK_GL_ERROR;
 
-            GLenum attachment = GL_COLOR_ATTACHMENT0;
-            GLenum draw_and_read_buf = GL_COLOR_ATTACHMENT0;
-            GLenum blit_type = GL_COLOR_BUFFER_BIT;
+            GL_ENTRYPOINT(glBindTexture)(tex_target, tex_handle);
+            VOGL_CHECK_GL_ERROR;
 
-            if ((m_desc.m_depth_size) && (m_desc.m_stencil_size))
+            if (m_desc.m_samples > 1)
             {
-                attachment = GL_DEPTH_STENCIL_ATTACHMENT;
-                draw_and_read_buf = GL_NONE;
-                blit_type = GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
+                GL_ENTRYPOINT(glTexImage2DMultisample)(tex_target,
+                    m_desc.m_samples,
+                    internal_fmt,
+                    m_desc.m_width,
+                    m_desc.m_height,
+                    GL_TRUE);
             }
-            else if (m_desc.m_depth_size)
+            else
             {
-                attachment = GL_DEPTH_ATTACHMENT;
-                draw_and_read_buf = GL_NONE;
-                blit_type = GL_DEPTH_BUFFER_BIT;
+                GL_ENTRYPOINT(glTexImage2D)(tex_target,
+                    0,
+                    internal_fmt,
+                    m_desc.m_width,
+                    m_desc.m_height,
+                    0,
+                    pInternal_tex_fmt->m_optimum_get_image_fmt,
+                    pInternal_tex_fmt->m_optimum_get_image_type,
+                    NULL);
             }
-            else if (m_desc.m_stencil_size)
+
+            if (!vogl_check_gl_error_internal())
             {
-                attachment = GL_STENCIL_ATTACHMENT;
-                draw_and_read_buf = GL_NONE;
-                blit_type = GL_STENCIL_BUFFER_BIT;
-            }
+                GL_ENTRYPOINT(glTexParameteri)(tex_target, GL_TEXTURE_MAX_LEVEL, 0);
+                VOGL_CHECK_GL_ERROR;
 
-            GLuint src_fbo_handle = 0, dst_fbo_handle = 0;
+                GLenum attachment = GL_COLOR_ATTACHMENT0;
+                GLenum draw_and_read_buf = GL_COLOR_ATTACHMENT0;
+                GLenum blit_type = GL_COLOR_BUFFER_BIT;
 
-            // Source FBO
-            GL_ENTRYPOINT(glGenFramebuffers)(1, &src_fbo_handle);
-            VOGL_CHECK_GL_ERROR;
+                if ((m_desc.m_depth_size) && (m_desc.m_stencil_size))
+                {
+                    attachment = GL_DEPTH_STENCIL_ATTACHMENT;
+                    draw_and_read_buf = GL_NONE;
+                    blit_type = GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
+                }
+                else if (m_desc.m_depth_size)
+                {
+                    attachment = GL_DEPTH_ATTACHMENT;
+                    draw_and_read_buf = GL_NONE;
+                    blit_type = GL_DEPTH_BUFFER_BIT;
+                }
+                else if (m_desc.m_stencil_size)
+                {
+                    attachment = GL_STENCIL_ATTACHMENT;
+                    draw_and_read_buf = GL_NONE;
+                    blit_type = GL_STENCIL_BUFFER_BIT;
+                }
 
-            GL_ENTRYPOINT(glBindFramebuffer)(GL_READ_FRAMEBUFFER, src_fbo_handle);
-            VOGL_CHECK_GL_ERROR;
+                GLuint src_fbo_handle = 0, dst_fbo_handle = 0;
 
-            GL_ENTRYPOINT(glFramebufferRenderbuffer)(GL_READ_FRAMEBUFFER, attachment, GL_RENDERBUFFER, m_snapshot_handle);
-            VOGL_CHECK_GL_ERROR;
+                // Source FBO
+                GL_ENTRYPOINT(glGenFramebuffers)(1, &src_fbo_handle);
+                VOGL_CHECK_GL_ERROR;
 
-            GL_ENTRYPOINT(glReadBuffer)(draw_and_read_buf);
-            VOGL_CHECK_GL_ERROR;
+                GL_ENTRYPOINT(glBindFramebuffer)(GL_READ_FRAMEBUFFER, src_fbo_handle);
+                VOGL_CHECK_GL_ERROR;
 
-            // Dest FBO
-            GL_ENTRYPOINT(glGenFramebuffers)(1, &dst_fbo_handle);
-            VOGL_CHECK_GL_ERROR;
+                GL_ENTRYPOINT(glFramebufferRenderbuffer)(GL_READ_FRAMEBUFFER, attachment, GL_RENDERBUFFER, m_snapshot_handle);
+                VOGL_CHECK_GL_ERROR;
 
-            GL_ENTRYPOINT(glBindFramebuffer)(GL_DRAW_FRAMEBUFFER, dst_fbo_handle);
-            VOGL_CHECK_GL_ERROR;
+                GL_ENTRYPOINT(glReadBuffer)(draw_and_read_buf);
+                VOGL_CHECK_GL_ERROR;
 
-            GL_ENTRYPOINT(glFramebufferTexture2D)(GL_DRAW_FRAMEBUFFER, attachment, tex_target, tex_handle, 0);
-            VOGL_CHECK_GL_ERROR;
+                // Dest FBO
+                GL_ENTRYPOINT(glGenFramebuffers)(1, &dst_fbo_handle);
+                VOGL_CHECK_GL_ERROR;
 
-            GL_ENTRYPOINT(glDrawBuffers)(1, &draw_and_read_buf);
-            VOGL_CHECK_GL_ERROR;
+                GL_ENTRYPOINT(glBindFramebuffer)(GL_DRAW_FRAMEBUFFER, dst_fbo_handle);
+                VOGL_CHECK_GL_ERROR;
 
-            GLenum read_status = GL_ENTRYPOINT(glCheckFramebufferStatus)(GL_READ_FRAMEBUFFER);
-            VOGL_CHECK_GL_ERROR;
+                GL_ENTRYPOINT(glFramebufferTexture2D)(GL_DRAW_FRAMEBUFFER, attachment, tex_target, tex_handle, 0);
+                VOGL_CHECK_GL_ERROR;
 
-            GLenum draw_status = GL_ENTRYPOINT(glCheckFramebufferStatus)(GL_DRAW_FRAMEBUFFER);
-            VOGL_CHECK_GL_ERROR;
+                GL_ENTRYPOINT(glDrawBuffers)(1, &draw_and_read_buf);
+                VOGL_CHECK_GL_ERROR;
 
-            if ((read_status == GL_FRAMEBUFFER_COMPLETE) && (draw_status == GL_FRAMEBUFFER_COMPLETE))
-            {
-                GL_ENTRYPOINT(glBlitFramebuffer)(
-                    0, 0, m_desc.m_width, m_desc.m_height,
-                    0, 0, m_desc.m_width, m_desc.m_height,
-                    blit_type,
-                    GL_NEAREST);
+                GLenum read_status = GL_ENTRYPOINT(glCheckFramebufferStatus)(GL_READ_FRAMEBUFFER);
+                VOGL_CHECK_GL_ERROR;
 
-                if (!vogl_check_gl_error_internal())
+                GLenum draw_status = GL_ENTRYPOINT(glCheckFramebufferStatus)(GL_DRAW_FRAMEBUFFER);
+                VOGL_CHECK_GL_ERROR;
+
+                if ((read_status == GL_FRAMEBUFFER_COMPLETE) && (draw_status == GL_FRAMEBUFFER_COMPLETE))
                 {
-                    vogl_handle_remapper def_handle_remapper;
-                    if (m_texture.snapshot(context_info, def_handle_remapper, tex_handle, tex_target))
-                        capture_status = true;
+                    GL_ENTRYPOINT(glBlitFramebuffer)(
+                        0, 0, m_desc.m_width, m_desc.m_height,
+                        0, 0, m_desc.m_width, m_desc.m_height,
+                        blit_type,
+                        GL_NEAREST);
+
+                    if (!vogl_check_gl_error_internal())
+                    {
+                        vogl_handle_remapper def_handle_remapper;
+                        if (m_texture.snapshot(context_info, def_handle_remapper, tex_handle, tex_target))
+                            capture_status = true;
+                    }
                 }
-            }
 
-            // Delete FBO
-            GL_ENTRYPOINT(glBindFramebuffer)(GL_DRAW_FRAMEBUFFER, 0);
-            VOGL_CHECK_GL_ERROR;
+                // Delete FBO
+                GL_ENTRYPOINT(glBindFramebuffer)(GL_DRAW_FRAMEBUFFER, 0);
+                VOGL_CHECK_GL_ERROR;
 
-            GL_ENTRYPOINT(glDeleteFramebuffers)(1, &dst_fbo_handle);
-            VOGL_CHECK_GL_ERROR;
+                GL_ENTRYPOINT(glDeleteFramebuffers)(1, &dst_fbo_handle);
+                VOGL_CHECK_GL_ERROR;
+
+                GL_ENTRYPOINT(glBindFramebuffer)(GL_READ_FRAMEBUFFER, 0);
+                VOGL_CHECK_GL_ERROR;
 
-            GL_ENTRYPOINT(glBindFramebuffer)(GL_READ_FRAMEBUFFER, 0);
+                GL_ENTRYPOINT(glDeleteFramebuffers)(1, &src_fbo_handle);
+                VOGL_CHECK_GL_ERROR;
+            }
+
+            GL_ENTRYPOINT(glBindTexture)(tex_target, 0);
             VOGL_CHECK_GL_ERROR;
 
-            GL_ENTRYPOINT(glDeleteFramebuffers)(1, &src_fbo_handle);
+            GL_ENTRYPOINT(glDeleteTextures)(1, &tex_handle);
             VOGL_CHECK_GL_ERROR;
         }
 
-        GL_ENTRYPOINT(glBindTexture)(tex_target, 0);
-        VOGL_CHECK_GL_ERROR;
-
-        GL_ENTRYPOINT(glDeleteTextures)(1, &tex_handle);
-        VOGL_CHECK_GL_ERROR;
-    }
-
-    if (!capture_status)
-    {
-        vogl_error_printf("%s: Failed blitting renderbuffer data to texture for renderbuffer %" PRIu64 "\n", VOGL_METHOD_NAME, static_cast<uint64_t>(handle));
+        if (!capture_status)
+        {
+            vogl_error_printf("%s: Failed blitting renderbuffer data to texture for renderbuffer %" PRIu64 "\n", VOGL_METHOD_NAME, static_cast<uint64_t>(handle));
+        }
     }
 
     m_is_valid = true;
@@ -474,149 +482,152 @@ bool vogl_renderbuffer_state::restore(const vogl_context_info &context_info, vog
     if (vogl_check_gl_error())
         goto handle_error;
 
-    if (!m_desc.restore(context_info))
-        goto handle_error;
-
-    if (m_texture.is_valid())
+    if ((m_desc.m_width) && (m_desc.m_height) && (m_desc.m_internal_format))
     {
-        GLenum attachment = GL_COLOR_ATTACHMENT0;
-        GLenum draw_and_read_buf = GL_COLOR_ATTACHMENT0;
-        GLenum blit_type = GL_COLOR_BUFFER_BIT;
+        if (!m_desc.restore(context_info))
+            goto handle_error;
 
-        if ((m_desc.m_depth_size) && (m_desc.m_stencil_size))
-        {
-            attachment = GL_DEPTH_STENCIL_ATTACHMENT;
-            draw_and_read_buf = GL_NONE;
-            blit_type = GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
-        }
-        else if (m_desc.m_depth_size)
-        {
-            attachment = GL_DEPTH_ATTACHMENT;
-            draw_and_read_buf = GL_NONE;
-            blit_type = GL_DEPTH_BUFFER_BIT;
-        }
-        else if (m_desc.m_stencil_size)
+        if (m_texture.is_valid())
         {
-            attachment = GL_STENCIL_ATTACHMENT;
-            draw_and_read_buf = GL_NONE;
-            blit_type = GL_STENCIL_BUFFER_BIT;
-        }
+            GLenum attachment = GL_COLOR_ATTACHMENT0;
+            GLenum draw_and_read_buf = GL_COLOR_ATTACHMENT0;
+            GLenum blit_type = GL_COLOR_BUFFER_BIT;
 
-        bool restore_status = false;
+            if ((m_desc.m_depth_size) && (m_desc.m_stencil_size))
+            {
+                attachment = GL_DEPTH_STENCIL_ATTACHMENT;
+                draw_and_read_buf = GL_NONE;
+                blit_type = GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
+            }
+            else if (m_desc.m_depth_size)
+            {
+                attachment = GL_DEPTH_ATTACHMENT;
+                draw_and_read_buf = GL_NONE;
+                blit_type = GL_DEPTH_BUFFER_BIT;
+            }
+            else if (m_desc.m_stencil_size)
+            {
+                attachment = GL_STENCIL_ATTACHMENT;
+                draw_and_read_buf = GL_NONE;
+                blit_type = GL_STENCIL_BUFFER_BIT;
+            }
 
-        GLuint64 tex_handle64 = 0;
-        vogl_handle_remapper def_handle_remapper;
-        if (m_texture.restore(context_info, def_handle_remapper, tex_handle64))
-        {
-            GLuint tex_handle = static_cast<GLuint>(tex_handle64);
+            bool restore_status = false;
 
-            const GLenum tex_target = (m_desc.m_samples > 1) ? GL_TEXTURE_2D_MULTISAMPLE : GL_TEXTURE_2D;
+            GLuint64 tex_handle64 = 0;
+            vogl_handle_remapper def_handle_remapper;
+            if (m_texture.restore(context_info, def_handle_remapper, tex_handle64))
+            {
+                GLuint tex_handle = static_cast<GLuint>(tex_handle64);
 
-            GLuint src_fbo_handle = 0, dst_fbo_handle = 0;
+                const GLenum tex_target = (m_desc.m_samples > 1) ? GL_TEXTURE_2D_MULTISAMPLE : GL_TEXTURE_2D;
 
-            // Source FBO
-            GL_ENTRYPOINT(glGenFramebuffers)(1, &src_fbo_handle);
-            VOGL_CHECK_GL_ERROR;
+                GLuint src_fbo_handle = 0, dst_fbo_handle = 0;
 
-            GL_ENTRYPOINT(glBindFramebuffer)(GL_READ_FRAMEBUFFER, src_fbo_handle);
-            VOGL_CHECK_GL_ERROR;
+                // Source FBO
+                GL_ENTRYPOINT(glGenFramebuffers)(1, &src_fbo_handle);
+                VOGL_CHECK_GL_ERROR;
 
-            GL_ENTRYPOINT(glFramebufferTexture2D)(GL_READ_FRAMEBUFFER, attachment, tex_target, tex_handle, 0);
-            VOGL_CHECK_GL_ERROR;
+                GL_ENTRYPOINT(glBindFramebuffer)(GL_READ_FRAMEBUFFER, src_fbo_handle);
+                VOGL_CHECK_GL_ERROR;
 
-            GL_ENTRYPOINT(glReadBuffer)(draw_and_read_buf);
-            VOGL_CHECK_GL_ERROR;
+                GL_ENTRYPOINT(glFramebufferTexture2D)(GL_READ_FRAMEBUFFER, attachment, tex_target, tex_handle, 0);
+                VOGL_CHECK_GL_ERROR;
 
-            // Dest FBO
-            GL_ENTRYPOINT(glGenFramebuffers)(1, &dst_fbo_handle);
-            VOGL_CHECK_GL_ERROR;
+                GL_ENTRYPOINT(glReadBuffer)(draw_and_read_buf);
+                VOGL_CHECK_GL_ERROR;
 
-            GL_ENTRYPOINT(glBindFramebuffer)(GL_DRAW_FRAMEBUFFER, dst_fbo_handle);
-            VOGL_CHECK_GL_ERROR;
+                // Dest FBO
+                GL_ENTRYPOINT(glGenFramebuffers)(1, &dst_fbo_handle);
+                VOGL_CHECK_GL_ERROR;
 
-            GL_ENTRYPOINT(glFramebufferRenderbuffer)(GL_DRAW_FRAMEBUFFER, attachment, GL_RENDERBUFFER, static_cast<GLuint>(handle));
-            VOGL_CHECK_GL_ERROR;
+                GL_ENTRYPOINT(glBindFramebuffer)(GL_DRAW_FRAMEBUFFER, dst_fbo_handle);
+                VOGL_CHECK_GL_ERROR;
 
-            GL_ENTRYPOINT(glDrawBuffers)(1, &draw_and_read_buf);
-            VOGL_CHECK_GL_ERROR;
+                GL_ENTRYPOINT(glFramebufferRenderbuffer)(GL_DRAW_FRAMEBUFFER, attachment, GL_RENDERBUFFER, static_cast<GLuint>(handle));
+                VOGL_CHECK_GL_ERROR;
 
-            GLenum read_status = GL_ENTRYPOINT(glCheckFramebufferStatus)(GL_READ_FRAMEBUFFER);
-            VOGL_CHECK_GL_ERROR;
+                GL_ENTRYPOINT(glDrawBuffers)(1, &draw_and_read_buf);
+                VOGL_CHECK_GL_ERROR;
 
-            GLenum draw_status = GL_ENTRYPOINT(glCheckFramebufferStatus)(GL_DRAW_FRAMEBUFFER);
-            VOGL_CHECK_GL_ERROR;
+                GLenum read_status = GL_ENTRYPOINT(glCheckFramebufferStatus)(GL_READ_FRAMEBUFFER);
+                VOGL_CHECK_GL_ERROR;
 
-            if ((read_status = GL_FRAMEBUFFER_COMPLETE) && (draw_status == GL_FRAMEBUFFER_COMPLETE))
-            {
-#if 0
-                // HACK HACK HACK
-                if (m_texture.get_num_samples() > 1)
-                {
-                    uint base_level = m_texture.get_params().get_value<GLenum>(GL_TEXTURE_BASE_LEVEL);
+                GLenum draw_status = GL_ENTRYPOINT(glCheckFramebufferStatus)(GL_DRAW_FRAMEBUFFER);
+                VOGL_CHECK_GL_ERROR;
 
-                    if (base_level < m_texture.get_num_levels())
+                if ((read_status = GL_FRAMEBUFFER_COMPLETE) && (draw_status == GL_FRAMEBUFFER_COMPLETE))
+                {
+    #if 0
+                    // HACK HACK HACK
+                    if (m_texture.get_num_samples() > 1)
                     {
-                        const vogl_state_vector &state_vec = m_texture.get_level_params(0, base_level);
+                        uint base_level = m_texture.get_params().get_value<GLenum>(GL_TEXTURE_BASE_LEVEL);
 
-                        uint clear_mask = 0;
-                        if (state_vec.get_value<GLenum>(GL_TEXTURE_DEPTH_SIZE))
-                        {
-                            clear_mask |= GL_DEPTH_BUFFER_BIT;
-                        }
-                        if (state_vec.get_value<GLenum>(GL_TEXTURE_STENCIL_SIZE))
-                        {
-                            clear_mask |= GL_STENCIL_BUFFER_BIT;
-                        }
-                        if (state_vec.get_value<GLenum>(GL_TEXTURE_RED_SIZE) + state_vec.get_value<GLenum>(GL_TEXTURE_GREEN_SIZE) + state_vec.get_value<GLenum>(GL_TEXTURE_BLUE_SIZE) + state_vec.get_value<GLenum>(GL_TEXTURE_ALPHA_SIZE) +
-                            state_vec.get_value<GLenum>(GL_TEXTURE_INTENSITY_SIZE) + state_vec.get_value<GLenum>(GL_TEXTURE_LUMINANCE_SIZE))
+                        if (base_level < m_texture.get_num_levels())
                         {
-                            clear_mask |= GL_COLOR_BUFFER_BIT;
+                            const vogl_state_vector &state_vec = m_texture.get_level_params(0, base_level);
+
+                            uint clear_mask = 0;
+                            if (state_vec.get_value<GLenum>(GL_TEXTURE_DEPTH_SIZE))
+                            {
+                                clear_mask |= GL_DEPTH_BUFFER_BIT;
+                            }
+                            if (state_vec.get_value<GLenum>(GL_TEXTURE_STENCIL_SIZE))
+                            {
+                                clear_mask |= GL_STENCIL_BUFFER_BIT;
+                            }
+                            if (state_vec.get_value<GLenum>(GL_TEXTURE_RED_SIZE) + state_vec.get_value<GLenum>(GL_TEXTURE_GREEN_SIZE) + state_vec.get_value<GLenum>(GL_TEXTURE_BLUE_SIZE) + state_vec.get_value<GLenum>(GL_TEXTURE_ALPHA_SIZE) +
+                                state_vec.get_value<GLenum>(GL_TEXTURE_INTENSITY_SIZE) + state_vec.get_value<GLenum>(GL_TEXTURE_LUMINANCE_SIZE))
+                            {
+                                clear_mask |= GL_COLOR_BUFFER_BIT;
+                            }
+
+                            GL_ENTRYPOINT(glClearColor)(1.0f, 0.0f, 1.0f, 1.0f);
+                            GL_ENTRYPOINT(glClearDepth)(.5f);
+                            GL_ENTRYPOINT(glClearStencil)(128);
+                            GL_ENTRYPOINT(glClear)(clear_mask);
+
+                            VOGL_CHECK_GL_ERROR;
                         }
-
-                        GL_ENTRYPOINT(glClearColor)(1.0f, 0.0f, 1.0f, 1.0f);
-                        GL_ENTRYPOINT(glClearDepth)(.5f);
-                        GL_ENTRYPOINT(glClearStencil)(128);
-                        GL_ENTRYPOINT(glClear)(clear_mask);
-
-                        VOGL_CHECK_GL_ERROR;
                     }
-                }
-                else
-#endif
-                {
-                    GL_ENTRYPOINT(glBlitFramebuffer)(
-                        0, 0, m_desc.m_width, m_desc.m_height,
-                        0, 0, m_desc.m_width, m_desc.m_height,
-                        blit_type,
-                        GL_NEAREST);
-
-                    if (!vogl_check_gl_error_internal())
+                    else
+    #endif
                     {
-                        restore_status = true;
+                        GL_ENTRYPOINT(glBlitFramebuffer)(
+                            0, 0, m_desc.m_width, m_desc.m_height,
+                            0, 0, m_desc.m_width, m_desc.m_height,
+                            blit_type,
+                            GL_NEAREST);
+
+                        if (!vogl_check_gl_error_internal())
+                        {
+                            restore_status = true;
+                        }
                     }
                 }
-            }
 
-            // Delete FBO
-            GL_ENTRYPOINT(glBindFramebuffer)(GL_DRAW_FRAMEBUFFER, 0);
-            VOGL_CHECK_GL_ERROR;
+                // Delete FBO
+                GL_ENTRYPOINT(glBindFramebuffer)(GL_DRAW_FRAMEBUFFER, 0);
+                VOGL_CHECK_GL_ERROR;
 
-            GL_ENTRYPOINT(glDeleteFramebuffers)(1, &dst_fbo_handle);
-            VOGL_CHECK_GL_ERROR;
+                GL_ENTRYPOINT(glDeleteFramebuffers)(1, &dst_fbo_handle);
+                VOGL_CHECK_GL_ERROR;
 
-            GL_ENTRYPOINT(glBindFramebuffer)(GL_READ_FRAMEBUFFER, 0);
-            VOGL_CHECK_GL_ERROR;
+                GL_ENTRYPOINT(glBindFramebuffer)(GL_READ_FRAMEBUFFER, 0);
+                VOGL_CHECK_GL_ERROR;
 
-            GL_ENTRYPOINT(glDeleteFramebuffers)(1, &src_fbo_handle);
-            VOGL_CHECK_GL_ERROR;
+                GL_ENTRYPOINT(glDeleteFramebuffers)(1, &src_fbo_handle);
+                VOGL_CHECK_GL_ERROR;
 
-            GL_ENTRYPOINT(glDeleteTextures)(1, &tex_handle);
-            VOGL_CHECK_GL_ERROR;
-        }
+                GL_ENTRYPOINT(glDeleteTextures)(1, &tex_handle);
+                VOGL_CHECK_GL_ERROR;
+            }
 
-        if (!restore_status)
-        {
-            vogl_error_printf("%s: Failed restoring contents of renderbuffer %u\n", VOGL_METHOD_NAME, static_cast<GLuint>(handle));
+            if (!restore_status)
+            {
+                vogl_error_printf("%s: Failed restoring contents of renderbuffer %u\n", VOGL_METHOD_NAME, static_cast<GLuint>(handle));
+            }
         }
     }