wxGLCanvas 调整大小后占用大量内存

Question

我已经创建了一个简单的 wxGLCanvas 来演示使用 wxWidgets 的 OpenGl。该演示运行良好，除了在调整 window 大小时内存使用量从几兆字节增加到近 400 兆字节并且它保持在那里并且没有减少，这里是代码片段。

// ctor
TriangleCanvas::TriangleCanvas(wxWindow* parent, wxGLAttributes& attribList)
    : wxGLCanvas(parent, attribList, wxID_ANY, { 0,0 }, wxDefaultSize),
    m_vbo(0), m_vao(0), ctx_attr(new wxGLContextAttrs)
{
    
    ctx_attr->CoreProfile().OGLVersion(4, 3).EndList();
    m_context = new wxGLContext(this, NULL, ctx_attr);
    Bind(wxEVT_PAINT, &TriangleCanvas::OnPaint, this);
    Bind(wxEVT_SIZE, &TriangleCanvas::Resize, this);
}


// Paint method
void TriangleCanvas::OnPaint(wxPaintEvent& event)
{
    wxPaintDC(this);
    SetCurrent(*m_context);
    shader->use();

    // set background to black
    glClearColor(0.0, 0.0, 0.0, 1.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // draw the graphics
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ebo);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
    
    glFlush();
    SwapBuffers();
}

void TriangleCanvas::Resize(wxSizeEvent& event) {
    event.Skip();
    glViewport(0, 0, event.GetSize().x, event.GetSize().y);

    if (!setup) {
        InitializeGLEW();
        SetupGraphics();
    }   
}

Answer 1

我认为将 wxGLCanvas 与扩展加载器一起使用的最佳方法是使用助手 class 并将所有 OpenGL 绘图保存在该助手的 cpp 部分 class。

比如这里有一个画三角形的小帮手class：

glhelper.h

#ifndef GLHELPER_H_INCLUDED
#define GLHELPER_H_INCLUDED

class GLHelper
{
public:
    bool InitGlew();
    void Render();
    void SetSize(int w, int h);

    bool InitData();
    void Cleanup();



private:
    unsigned int m_VBO, m_VAO, m_shaderProgram;
};


#endif // GLHELPER_H_INCLUDED

glhelper.cpp

#include <GL/glew.h>

#ifdef __WXMSW__
    #include <GL/wglew.h>
#elif defined(__WXGTK__)
    #include <GL/glxew.h>
#endif // defined

#include "glhelper.h"

static const char *vertexShaderSource = "#version 330 core\n"
    "layout (location = 0) in vec3 aPos;\n"
    "void main()\n"
    "{\n"
    "   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
    "}[=11=]";
static const char *fragmentShaderSource = "#version 330 core\n"
    "out vec4 FragColor;\n"
    "void main()\n"
    "{\n"
    "   FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
    "}\n[=11=]";

bool GLHelper::InitGlew()
{
    GLenum initStatus = glewInit();

    return initStatus == GLEW_OK;
}

bool GLHelper::InitData()
{
    unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    glCompileShader(vertexShader);
    // check for shader compile errors
    int success;
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        return false;
    }
    // fragment shader
    unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);
    // check for shader compile errors
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        return false;
    }
    // link shaders
    m_shaderProgram = glCreateProgram();
    glAttachShader(m_shaderProgram, vertexShader);
    glAttachShader(m_shaderProgram, fragmentShader);
    glLinkProgram(m_shaderProgram);
    // check for linking errors
    glGetProgramiv(m_shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        return false;
    }
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    // set up vertex data (and buffer(s)) and configure vertex attributes
    // ------------------------------------------------------------------
    float vertices[] = {
        -0.5f, -0.5f, 0.0f, // left
         0.5f, -0.5f, 0.0f, // right
         0.0f,  0.5f, 0.0f  // top
    };

    //unsigned int VBO, VAO;
    glGenVertexArrays(1, &m_VAO);
    glGenBuffers(1, &m_VBO);
    // bind the Vertex Array Object first, then bind and set vertex buffer(s),
    // and then configure vertex attributes(s).
    glBindVertexArray(m_VAO);

    glBindBuffer(GL_ARRAY_BUFFER, m_VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    // note that this is allowed, the call to glVertexAttribPointer registered
    //VBO as the vertex attribute's bound vertex buffer object so afterwards we
    //can safely unbind
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    // You can unbind the VAO afterwards so other VAO calls won't accidentally
    //modify this VAO, but this rarely happens. Modifying other VAOs requires a
    //call to glBindVertexArray anyways so we generally don't unbind VAOs (nor
    // VBOs) when it's not directly necessary.
    glBindVertexArray(0);

    return true;
}

void GLHelper::Cleanup()
{
    glDeleteVertexArrays(1, &m_VAO);
    glDeleteBuffers(1, &m_VBO);
    glDeleteProgram(m_shaderProgram);
}

void GLHelper::Render()
{
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);

    // draw our first triangle
    glUseProgram(m_shaderProgram);
    glBindVertexArray(m_VAO);
    // seeing as we only have a single VAO there's no need to bind it every
    //time, but we'll do so to keep things a bit more organized
    glDrawArrays(GL_TRIANGLES, 0, 3);
}

void GLHelper::SetSize(int width, int height)
{
    glViewport(0, 0, width, height);
}

这是一个简短的演示，它使用这个助手 class 来绘制三角形。

demo.cpp

#include "wx/wx.h"

#include <wx/glcanvas.h>
#include "glhelper.h"

class wxGlewFrame: public wxFrame
{
    public:
        wxGlewFrame(wxWindow*);
        ~wxGlewFrame();
    private:
        void OnCanvasSize(wxSizeEvent&);
        void OnCanvasPaint(wxPaintEvent&);

        void InitGL();

        wxGLCanvas* m_canvas;
        wxGLContext* m_context;
        GLHelper m_helper;
};

wxGlewFrame::wxGlewFrame(wxWindow* parent)
    : wxFrame(parent,  wxID_ANY, wxString())
{
    // Create the canvas and context.
    #if wxCHECK_VERSION(3,1,0)
        // These settings should work with any GPU from the last 10 years.
        wxGLAttributes dispAttrs;
        dispAttrs.PlatformDefaults().RGBA().DoubleBuffer().EndList();

        wxGLContextAttrs cxtAttrs;
        cxtAttrs.PlatformDefaults().CoreProfile().OGLVersion(3, 3).EndList();

        m_canvas = new wxGLCanvas(this, dispAttrs);
        m_context = new wxGLContext(m_canvas, NULL, &cxtAttrs);

        if ( !m_context->IsOK() )
        {
            SetTitle("Failed to create context.");
            return;
        }
    #else
        int dispAttrs[] = { WX_GL_RGBA, WX_GL_DOUBLEBUFFER, WX_GL_CORE_PROFILE,
                            WX_GL_MAJOR_VERSION ,3, WX_GL_MINOR_VERSION, 3, 0 };

        m_canvas = new wxGLCanvas(this, wxID_ANY, dispAttrs);
        m_context = new wxGLContext(m_canvas, NULL);

        // Unfortunately, there doesn't seem to be any way to check if the
        // context is ok prior to wxWidgets 3.1.0.
    #endif // wxCHECK_VERSION

    // On Linux, we must delay delay initialization until the canvas has
    // been full created.  On windows, we can finish now.
    #ifdef __WXMSW__
        InitGL();
    #elif defined(__WXGTK__)
        m_canvas->Bind(wxEVT_CREATE, [this](wxWindowCreateEvent&){InitGL();});
    #endif // defined
}

wxGlewFrame::~wxGlewFrame()
{
    m_helper.Cleanup();
    delete m_context;
}

void wxGlewFrame::OnCanvasSize(wxSizeEvent& event)
{
    wxSize sz = event.GetSize();
    m_helper.SetSize(sz.GetWidth(), sz.GetHeight());
    event.Skip();
}

void wxGlewFrame::OnCanvasPaint(wxPaintEvent&)
{
    wxPaintDC dc(m_canvas);

    m_helper.Render();
    m_canvas->SwapBuffers();
}

void wxGlewFrame::InitGL()
{
    // First call SetCurrent or GL initialization will fail.
    m_context->SetCurrent(*m_canvas);

    // Initialize GLEW.
    bool glewInialized = m_helper.InitGlew();

    if ( !glewInialized )
    {
        SetTitle("Failed it initialize GLEW.");
        return;
    }

    SetTitle("Context and GLEW initialized.");

    // Initialize the triangle data.
    m_helper.InitData();

    // Bind event handlers for the canvas. Binding was delayed until OpenGL was
    // initialized because these handlers will need to call OpenGL functions.
    m_canvas->Bind(wxEVT_SIZE, &wxGlewFrame::OnCanvasSize, this);
    m_canvas->Bind(wxEVT_PAINT, &wxGlewFrame::OnCanvasPaint, this);
}

class MyApp : public wxApp
{
    public:
        virtual bool OnInit()
        {
            wxGlewFrame* frame = new wxGlewFrame(NULL);
            frame->Show();
            return true;
        }
};

wxIMPLEMENT_APP(MyApp);

（这基本上是 Hello Triangle sample from learnopengl.com 除了重写为使用 wxGLCanvas 和 GLEW 而不是 GLFW 和 GLAD。

这在我的系统上占用了大约 19MB 的内存，并且在调整大小时最多只增加了大约 24 或 25MB。对于这样一个简单的程序来说，这听起来可能很多，但是运行官方“Hello Triangle”示例使用了 26MB。所以我认为内存使用量应该是预期的。

wxGLCanvas 调整大小后占用大量内存

wxGLCanvas huge memory usage after resizing

c++

opengl

wxwidgets