flowvis_canvas.cpp

Go to the documentation of this file.

#include <glew.h>

#include "flowvis_canvas.h"


#include <wx/dcclient.h>
#include <wx/image.h>

#include <algorithm>
#include <stdexcept>

BEGIN_EVENT_TABLE(FlowVisCanvas, wxGLCanvas)
    EVT_PAINT(FlowVisCanvas::OnPaint)
    EVT_SIZE(FlowVisCanvas::OnSize)
    EVT_ERASE_BACKGROUND(FlowVisCanvas::OnEraseBackground)
END_EVENT_TABLE()

namespace
{
    int attrib_list[] = { WX_GL_RGBA, WX_GL_DOUBLEBUFFER, 0 };

    std::pair<float, float> ComputeScaleFactors(float a1, float a2)
    {
        const float x = a2 / a1;
        if (x > 1.0f) return std::make_pair(1.0f, 1.0f / x);
        else return std::make_pair(x, 1.0f);
    }
}

FlowVisCanvas::FlowVisCanvas(wxWindow *parent, wxWindowID id)
    : wxGLCanvas(parent, id, wxDefaultPosition, wxDefaultSize, wxFULL_REPAINT_ON_RESIZE, wxGLCanvasName, attrib_list)
    , m_mode(FVC_SCREEN)
    , m_glstatus(GLS_INIT_PENDING)
    , m_data(0)
    , m_background_set(-1)
    , m_plot_background(true)
{
    if (!CheckGL()) throw std::runtime_error("OpenGL Initialization failed");

    LoadGlyphTexture();

    m_program = std::auto_ptr<FlowVisProgram>(new FlowVisProgram("flow_prog"));
    LoadArrowTexture();

    m_arrow_data.nr_x = 10;
    m_arrow_data.nr_y = 10;
    m_arrow_data.plot = false;
}

void FlowVisCanvas::SetData(std::auto_ptr<FlowVisData> data)
{
    if(!data.get()) return;
    m_data = data;
    m_background_set = 0;

    InitTextures();
    Render_ValueInter(0);
    Render_ValueInter(1);
    SetArrows(30, 30);
    Prepare_Streamlines();

    Refresh();
}

void FlowVisCanvas::OnPaint(wxPaintEvent &event )
{
    wxPaintDC dc(this);
    if (!CheckGL()) return;

    GetClientSize(&m_viewport_width, &m_viewport_height);
    //m_line_base_thickness = (std::min(m_viewport_width, m_viewport_height) / 4096.0f) * 6.0f;
    m_line_base_thickness = 2.0f;

    Render();
    SwapBuffers();
}

void FlowVisCanvas::OnSize(wxSizeEvent &event)
{
    wxGLCanvas::OnSize(event);

    Update();
}

void FlowVisCanvas::OnEraseBackground(wxEraseEvent &event)
{
    // Do nothing, to avoid flashing.
}

void FlowVisCanvas::LoadArrowTexture()
{
    wxImage img;
    img.AddHandler(new wxPNGHandler());
    if(img.LoadFile(wxT("images/arrow.png")))
    {
        unsigned char *orig_data = img.GetData();

        std::vector<unsigned char> data(16 * 16 * 4);

        for(int i = 0; i < 16 * 16; i++)
        {
            data[i * 4] = orig_data[i * 3];
            data[i * 4 + 1] = orig_data[i * 3 + 1];
            data[i * 4 + 2] = orig_data[i * 3 + 2];
            data[i * 4 + 3] = orig_data[i * 3];
        }

        glGenTextures(1, &(m_arrow_data.arrow_texture));
        glBindTexture(GL_TEXTURE_2D, m_arrow_data.arrow_texture);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, &(data[0]));
    }else
    {
        throw std::runtime_error("Could not load arrow texture from filesystem!");
    }
}

void FlowVisCanvas::LoadGlyphTexture()
{
    wxImage img;
    img.AddHandler(new wxPNGHandler());
    if(img.LoadFile(wxT("images/glyph2.png")))
    {
        unsigned char *orig_data = img.GetData();

        int h = img.GetHeight();
        int w = img.GetWidth();

        std::vector<unsigned char> data(h * w * 4);

        for(int i = 0; i < h * w; i++)
        {
            data[i * 4] = orig_data[i * 3];
            data[i * 4 + 1] = orig_data[i * 3 + 1];
            data[i * 4 + 2] = orig_data[i * 3 + 2];
            data[i * 4 + 3] = orig_data[i * 3];
        }

        glGenTextures(1, &(m_sl_settings.glyph_texture));
        glBindTexture(GL_TEXTURE_2D, m_sl_settings.glyph_texture);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, h, w, 0, GL_RGBA, GL_UNSIGNED_BYTE, &(data[0]));
    }else
    {
        throw std::runtime_error("Could not load glyph texture from filesystem!");
    }
}

namespace
{
    struct TEST_S
    {
        TEST_S(float x_, float y_, int grad_ = -1)
            : x(x_)
            , y(y_)
            , grad(grad_)
        {
        }
        float x;
        float y;
        int grad;
    };
}

void FlowVisCanvas::Render()
{
    std::vector<TEST_S> test;
    float pi = 3.14159265f;

    float test1 = AngleR(vec3(0, 1));

    for(float i = -1; i <= 1; i+= 0.1f)
    {
        for(float j = -1; j < 1; j+=0.1f)
        {
            test.push_back(TEST_S(i, j, AngleR(vec3(i, j)) / pi * 180));
        }
    }

    if(m_data.get())
    {
        Render_ToScreen();
    }
}

void FlowVisCanvas::Render_Background()
{
    glEnable(GL_TEXTURE_2D);

    glBindTexture(GL_TEXTURE_2D, m_tex_background[m_background_set]);

    m_program->SetMode(FlowVisProgram::M_BG_INTER);
    m_program->SetBGDataTexture(m_tex_background[m_background_set]);
    m_program->SetTransferFunctionTexture(m_tex_bg_trafu[m_background_set]);
    m_program->Use();

    glBegin(GL_QUADS);
        glTexCoord2f(0, 0);
        glVertex2f(-1, -1);
        glTexCoord2f(1, 0);
        glVertex2f(1, -1);
        glTexCoord2f(1, 1);
        glVertex2f(1, 1);
        glTexCoord2f(0, 1);
        glVertex2f(-1, 1);
    glEnd();

    m_program->Stop();

    glDisable(GL_TEXTURE_2D);
}

void FlowVisCanvas::Render_Streamlines()
{
    float w_max = -999999;
    float w_min = 999999;

    //Point Sprite preperations
    glPointSize( 8.0f );
    glTexEnvf( GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE );
    glEnable( GL_POINT_SPRITE_ARB );

    glEnable(GL_TEXTURE_2D);

    m_program->SetMode(FlowVisProgram::M_TEXTURE_ROTATION);
    m_program->SetGlyphTexture(m_sl_settings.glyph_texture);
    m_program->Prepare();
    glBindTexture(GL_TEXTURE_2D, m_sl_settings.glyph_texture);

    glDisable(GL_TEXTURE_2D);

    Streamline::iterator last_point;

    glEnable(GL_LINE_SMOOTH);

    glColor3f(m_sl_settings.color.red,m_sl_settings.color.green,m_sl_settings.color.blue);

    for(std::vector<Streamline>::iterator lines_iter = m_streamlines.begin();
        lines_iter != m_streamlines.end();
        ++lines_iter)
    {
        int i = 0;
        last_point = lines_iter->end();
        if(m_sl_settings.plot_tapering)
            glLineWidth(m_line_base_thickness * lines_iter->begin()->thickness);
        else
            glLineWidth(1.0f);
        glBegin(GL_LINE_STRIP);
            for(Streamline::iterator iter = lines_iter->begin();
                iter != lines_iter->end();
                ++iter)
            {
                if(m_sl_settings.plot_tapering && last_point != lines_iter->end())
                {
                    if(last_point->thickness != iter->thickness)
                    {
                        glEnd();
                        if(m_sl_settings.plot_tapering)
                            glLineWidth(m_line_base_thickness * iter->thickness);
                        glBegin(GL_LINE_STRIP);
                    }
                    glVertex2f(last_point->pos.x, last_point->pos.y);
                }
                glVertex2f(iter->pos.x, iter->pos.y);
                last_point = iter;

                if((m_sl_settings.plot_glyphs) && !(i++ % (110 - m_sl_settings.glyph_density)))
                {
                    glEnd();

                    glEnable(GL_TEXTURE_2D);
                    m_program->Start();

                    float pi = 3.14159265f;
                    float my_winkel = pi - AngleR(m_data->GetVelocityAt(iter->pos.x, iter->pos.y));
                    if(my_winkel < 0)
                    {
                        my_winkel = 2 * pi + my_winkel;
                    }

                    my_winkel = my_winkel / (2 * pi);
                    //float my_winkel = AngleR(vec3(0, 1)) / (2 * pi);
                    
                    glBegin(GL_POINTS);
                    glColor4f(m_sl_settings.color.red,
                        m_sl_settings.color.green,
                        m_sl_settings.color.blue,
                        my_winkel);
                    glVertex2f(iter->pos.x, iter->pos.y);
                    glColor3f(m_sl_settings.color.red,m_sl_settings.color.green,m_sl_settings.color.blue);
                    glEnd();
                    m_program->Stop();

                    glDisable(GL_TEXTURE_2D);

                    glBegin(GL_LINE_STRIP);
                }
            }
        glEnd();
    }

    glDisable( GL_POINT_SPRITE_ARB );

    glDisable(GL_LINE_SMOOTH);
}

void FlowVisCanvas::Render_Arrows()
{
    //Point Sprite preperations
    //glPointSize( 10.0f );
    //glTexEnvf( GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE );
    //glEnable( GL_POINT_SPRITE_ARB );

    //Bleding Preperations
    glEnable( GL_BLEND );
    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );

    //Texture Preperations)
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, m_arrow_data.arrow_texture);

    glMatrixMode(GL_MODELVIEW);

    float data_width = m_data->m_grid_max.v[0] - m_data->m_grid_min.v[0];
    float data_height = m_data->m_grid_max.v[1] - m_data->m_grid_min.v[1];

    float aspect = static_cast<float> (m_viewport_width) / m_viewport_height;
    std::pair<float, float> scale = ComputeScaleFactors(aspect, static_cast<float> (data_width) / data_height);

    float min_length = 99999;
    float max_length = -99999;

    for(ArrowPoints_T::const_iterator citer = m_arrow_data.arrow_points.begin();
        citer != m_arrow_data.arrow_points.end();
        ++citer)
    {
        glPushMatrix();

        float length = citer->length / m_data->m_max_velocity_length;
        glTranslatef(citer->x, citer->y, 0.0f);
        glScalef(1 / scale.first, 1 / scale.second, 1.0f);
        glRotatef(citer->rotation, 0.0f, 0.0f, 1.0f);

        glColor3f(1.0f, 1.0f, 1.0f);

        min_length = std::min(min_length, length);
        max_length = std::max(max_length, length);

        glPushMatrix();
        glScalef(0.2f + 0.8f * length, 0.2f + 0.8f * length, 1.0f);

        glBegin(GL_QUADS);
        glTexCoord2f(0.0f, 0.0f);
        glVertex2f(-0.04f, -0.04f);
        glTexCoord2f(1.0f, 0.0f);
        glVertex2f(0.04f, -0.04f);
        glTexCoord2f(1.0f, 1.0f);
        glVertex2f(0.04f, 0.04f);
        glTexCoord2f(0.0f, 1.0f);
        glVertex2f(-0.04f, 0.04f);
        glEnd();

        glPopMatrix();

        glPopMatrix();
    }

    glDisable( GL_POINT_SPRITE_ARB );

    glDisable(GL_TEXTURE_2D);

    //glDisable( GL_BLEND );
}


void FlowVisCanvas::Render_ToScreen()
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glViewport(0, 0, m_viewport_width, m_viewport_height);
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    float data_width = m_data->m_grid_max.v[0] - m_data->m_grid_min.v[0];
    float data_height = m_data->m_grid_max.v[1] - m_data->m_grid_min.v[1];

    float aspect = static_cast<float> (m_viewport_width) / m_viewport_height;
    std::pair<float, float> scale = ComputeScaleFactors(aspect, static_cast<float> (data_width) / data_height);
    glScalef(scale.first, scale.second, 1.0f);

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    if(m_plot_background) Render_Background();

    if(m_sl_settings.plot) Render_Streamlines();

    if(m_arrow_data.plot) Render_Arrows();
}

void FlowVisCanvas::Render_ValueInter(int set)
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glEnable(GL_TEXTURE_2D);

    int size = 512;

    glViewport(0, 0, size, size);
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);


    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);

    VertexData_T vdata = m_data->GetVertexData();
    ColorData_T cdata = m_data->GetColorData(0, set);
    IndexData_T idata = m_data->GetIndexData();

    glVertexPointer(2, GL_FLOAT, 0, &(vdata[0]));
    glColorPointer(3, GL_FLOAT, 0, &(cdata[0]));
    int cells = (m_data->GetWidth() - 1) * (m_data->GetHeight() - 1) * 4;

    glDrawElements(GL_QUADS, cells, GL_UNSIGNED_INT, &(idata[0]));

    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_COLOR_ARRAY);

    glBindTexture(GL_TEXTURE_2D, m_tex_background[set]);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size, size, 0, GL_RGBA, GL_FLOAT, NULL);
    glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, size, size, 0);
}

bool FlowVisCanvas::InitGL()
{
    if (glewInit() != GLEW_NO_ERROR) return false;


    return true;
}

bool FlowVisCanvas::CheckGL()
{
    #ifndef __WXMOTIF__
        if (!GetContext()) return false;
    #endif

    SetCurrent();
    if (m_glstatus == GLS_INIT_PENDING) m_glstatus = InitGL() ? GLS_OK : GLS_INIT_FAILED;
    if (m_glstatus != GLS_OK) return false;
    return true;
}

void FlowVisCanvas::SetBackgroundSet(int set_nr)
{
    m_background_set = set_nr;
}

void FlowVisCanvas::InitTextures()
{
    // Init Background Data Textures
    for(unsigned int i = 0; i < m_tex_background.size(); i++)
    {
        glDeleteTextures(1, &m_tex_background[i]);
    }

    m_tex_background.clear();

    for(int i = 0; i < m_data->GetNrSets(); i++)
    {
        GLuint id;
        glGenTextures(1, &id);
        glBindTexture(GL_TEXTURE_2D, id);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

        m_tex_background.push_back(id);
    }

    //Init Background Transfer Function Textures
    for(unsigned int i = 0; i < m_tex_bg_trafu.size(); i++)
    {
        glDeleteTextures(1, &m_tex_bg_trafu[i]);
    }

    m_tex_bg_trafu.clear();

    for(int i = 0; i < m_data->GetNrSets(); i++)
    {
        GLuint id;
        glGenTextures(1, &id);
        glBindTexture(GL_TEXTURE_1D, id);
        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

        m_tex_bg_trafu.push_back(id);
    }
}

void FlowVisCanvas::UpdateTransferFunction(TransferFunctionSampler *sampler, int set_to_update)
{
    std::vector<float> data;

    // make sure density 0 is mapped to a completely transparent color
    data.push_back(0.0f);
    data.push_back(0.0f);
    data.push_back(0.0f);
    data.push_back(0.0f);

    for (int i = 1; i < 4096; ++i) {
        const TransferFunctionSampler::Color c = sampler->MapDensity(i / 4095.0f);
        data.push_back(c.r);
        data.push_back(c.g);
        data.push_back(c.b);
        data.push_back(c.a);
    }

    glBindTexture(GL_TEXTURE_1D, m_tex_bg_trafu[set_to_update]);
    glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, 4096, 0, GL_RGBA, GL_FLOAT, &data[0]);

    Refresh();
}

void FlowVisCanvas::CreateEvenlySpacedArrows()
{
    //TODO: Create evenly spaced arrows ... properly this time

    float space_x = 2.0f / m_arrow_data.nr_x;
    float space_y = 2.0f / m_arrow_data.nr_y;
    float x, y;
    vec3 velocity;

    vec3 m_grid_size = m_data->m_grid_max - m_data->m_grid_min;

    m_arrow_data.arrow_points.clear();

    m_arrow_data.arrow_points.reserve(m_arrow_data.nr_x * m_arrow_data.nr_y);

    for(int i = 0; i < m_arrow_data.nr_x; i++)
    {
        for(int j = 0; j < m_arrow_data.nr_y; j++)
        {
            x = space_x * i - 1 + space_x / 2;
            y = space_y * j - 1 + space_y / 2;
            velocity = m_data->GetVelocityAt(x, y);
            m_arrow_data.arrow_points.push_back(ArrowPoint(x,
                y,
                velocity));
        }
    }
}

void FlowVisCanvas::SetArrows(int x, int y)
{
    m_arrow_data.nr_x = x;
    m_arrow_data.nr_y = y;
    CreateEvenlySpacedArrows();
    Refresh();
}

void FlowVisCanvas::SetArrowPlot(bool plot_arrows)
{
    m_arrow_data.plot = plot_arrows;
    Refresh();
}

void FlowVisCanvas::SetStreamlinePlot(bool plot_streamlines)
{
    m_sl_settings.plot = plot_streamlines;
}

void FlowVisCanvas::SetBackgroundPlot(bool plot_background)
{
    m_plot_background = plot_background;
    Refresh();
}

void FlowVisCanvas::Prepare_Streamlines()
{
    const SL_Rectangle domain(-1.0f, -1.0f, 1.0f, 1.0f);
    const int maxiter = m_sl_algorithm.maxiter;
    const float stepsize = m_sl_algorithm.stepsize;
    const float dsep = m_sl_algorithm.dsep;
    const float dtest = m_sl_algorithm.dtest;
    const SLIterAlg alg = m_sl_algorithm.interploation;
    StreamlineGenerator sgl(domain, dsep, dtest, stepsize, maxiter, VelocityFunctor(m_data.get()), alg);
    m_streamlines.clear();
    m_streamlines = sgl.GetStreamlines();
}

void FlowVisCanvas::SetLineColor(wxColour new_color)
{
    m_sl_settings.color = new_color;
}

void FlowVisCanvas::SetLineTapering(bool plot_tapering)
{
    m_sl_settings.plot_tapering = plot_tapering;
}

void FlowVisCanvas::SetLineGlyphs(bool plot_glyphs)
{
    m_sl_settings.plot_glyphs = plot_glyphs;
}

void FlowVisCanvas::SetGlyphDensity(int new_density)
{
    m_sl_settings.glyph_density = new_density;
}

void FlowVisCanvas::SetDsep(float dsep)
{
    m_sl_algorithm.dsep = dsep;
}

void FlowVisCanvas::SetDtest(float dtest)
{
    m_sl_algorithm.dtest = dtest;
}

void FlowVisCanvas::SetIntegType(int integ_index)
{
    m_sl_algorithm.interploation = (integ_index)?(ITER_EULER):(ITER_RK);
}

void FlowVisCanvas::SetMaxIter(int maxiter)
{
    m_sl_algorithm.maxiter = maxiter;
}

void FlowVisCanvas::SetStepSize(float step_size)
{
    m_sl_algorithm.stepsize = step_size;
}

void FlowVisCanvas::RenderToFile(const wxString& file_name, int width, int height)
{
    //TODO: Clean up RenderToFile ... it's ugly (though it works ... hopefully)

    if (!CheckGL()) return;

    GLuint id_rbf;
    GLuint id_fbo;

    //Create and bind Frame Buffer Object
    glGenFramebuffersEXT(1, &id_fbo);
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, id_fbo);
    
    //Create and bind Render Buffer
    glGenRenderbuffersEXT(1, &id_rbf);
    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, id_rbf);
    
    glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA, width, height);
    
    //Attach renderbuffer to framebuffer
    glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, id_rbf);
    
    //If framebuffer status ok -> render offscreen image and save to file
    if (GL_FRAMEBUFFER_COMPLETE_EXT == glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT))
    {
        m_viewport_width = width;
        m_viewport_height = height;

        Render_ToScreen();

        unsigned char *rgb = (unsigned char*)malloc(width * height * 3);
        unsigned char *alpha = (unsigned char*)malloc(width * height);

        glPixelStorei(GL_PACK_ALIGNMENT, 1);
        glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, rgb);
        glReadPixels(0, 0, width, height, GL_ALPHA, GL_UNSIGNED_BYTE, alpha);
        glPixelStorei(GL_PACK_ALIGNMENT, 4);

        wxImage img(width, height);
        img.SetData(rgb);
        img.SetAlpha(alpha);
        img = img.Mirror(false);

        if (!img.SaveFile(file_name)) {
            // TODO: react on failure
        }
    } else {
        //TODO: react on frame/renderbuffer error
    }

    //Unbind frame buffer
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

    //Delete renderbuffer
    glDeleteRenderbuffersEXT(1, &id_rbf);

    //Delete framebuffer
    glDeleteFramebuffersEXT(1, &id_fbo);

    GetClientSize(&m_viewport_width, &m_viewport_height);
}

---