How to decently destroy opengl resources when using QOpenGLWidget in pyqt5

Question

First of all, My codes are as follows:

from PyQt5.QtWidgets import QApplication, QOpenGLWidget, QMainWindow
from PyQt5.QtGui import QPainter, QOpenGLShader, QOpenGLShaderProgram, QMatrix4x4, QOpenGLBuffer, QOpenGLVertexArrayObject
from PyQt5.QtCore import Qt, QTimer

import numpy as np
import OpenGL.GL as gl
import sys

class OpenGLWidget(QOpenGLWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.frame_count = 0

    def initializeGL(self):
        self.program = QOpenGLShaderProgram()
        self.program.addShaderFromSourceCode(QOpenGLShader.Vertex, """
            attribute highp vec4 aPos;
            void main() {
                gl_Position = aPos;
            }
        """)
        self.program.addShaderFromSourceCode(QOpenGLShader.Fragment, """
            void main() {
                gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
            }
        """)

        self.program.link()
        self.program.bind()

        self.vertices = np.array([
            [-0.5, -0.5, 0.0, 1.0],
            [0.0, -0.5, 0.0, 1.0],
            [-0.25, 0.0, 0.0, 1.0],
            [-0.5, 0.5, 0.0, 1.0],
            [0.0, 0.5, 0.0, 1.0],
        ], dtype=np.float32)

        self.indices = np.array([
            0,1,2,2,3,4
        ], dtype=np.uint16)
        
        self.vao = QOpenGLVertexArrayObject()
        self.vbo = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer)
        self.ibo = QOpenGLBuffer(QOpenGLBuffer.IndexBuffer)
        self.vao.create()
        self.vbo.create()
        self.ibo.create()
        self.vao.bind()        
        self.vbo.bind()
        self.ibo.bind()
        self.vbo.allocate(self.vertices.nbytes)
        self.ibo.allocate(self.indices.nbytes)
        self.vbo.write(0, self.vertices.tobytes(), self.vertices.nbytes)        
        self.ibo.write(0, self.indices.tobytes(), self.indices.nbytes)
        posAttribLoc = self.program.attributeLocation("aPos")
        self.program.setAttributeBuffer(posAttribLoc, gl.GL_FLOAT, 0, 4, 0)
        self.program.enableAttributeArray(posAttribLoc) 
        self.vbo.release()
        self.vao.release()
    
    def paintGL(self):
        gl = self.context().versionFunctions() 
        gl.glClearColor(0.33,0.33,0.33, 1.0)
        gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
        self.vao.bind()
        self.program.bind()

        gl.glDrawElements(gl.GL_TRIANGLES, len(self.indices), gl.GL_UNSIGNED_SHORT, None)
        self.frame_count += 1
    
    def resizeGL(self, width, height):
        gl.glViewport(0, 0, width, height)
    
    def __del__(self):
        self.vao.destroy()
        self.vbo.destroy()
        self.ibo.destroy()        
        self.program.removeAllShaders()
        pass

if __name__ == '__main__':
    app = QApplication(sys.argv)
    widget = OpenGLWidget()
    window = QMainWindow()    
    window.setCentralWidget(widget)
    window.setGeometry(0,0,640,480)
    window.show()
    sys.exit(app.exec_())

Everything goes well, I can render it as expected. But python complains:

in __del__
RuntimeError: wrapped C/C++ object of type QOpenGLVertexArrayObject has been deleted

when I close the window. Guess the buffer is freed twice so I change the destructor to

    def __del__(self):
        pass

while the interpreter complain

QOpenGLVertexArrayObject::destroy() failed to restore current context

After closing. I think there must be something wrong on freeing, can anyone figure out proper way to release these buffers?

UPDAETE
Enlightened by Resource Initialization and Cleanup topic within Qt doc, we can connect aboutToBeDestroyed signal to a customized slot function for cleanup:

    def __init__(self, parent=None):
        super().__init__(parent)
        self.frame_count = 0
        self.glContext = None

    def paintGL(self):
        if self.glContext is None: 
            self.glContext = self.context()
            self.glContext.aboutToBeDestroyed.connect(self.cleanup)

        gl = self.glContext.versionFunctions() 
        gl.glClearColor(0.33,0.33,0.33, 1.0)
        gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
        self.vao.bind()
        self.program.bind()

        gl.glDrawElements(gl.GL_TRIANGLES, len(self.indices), gl.GL_UNSIGNED_SHORT, None)
        self.frame_count += 1

    def cleanup(self):
        print('cleanup called')
        self.makeCurrent()
        self.vao.destroy()
        self.vbo.destroy()
        self.ibo.destroy()        
        self.program.removeAllShaders()
        self.doneCurrent()

However, cleanup still not called after closing window

score 0 · Answer 1 · answered May 12 '23 at 19:09

0

If you would like to run cleanup methods when a window is closed, I would recommend overloading the widget's closeEvent like so:

class OpenGLWidget(QOpenGLWidget):
    ...

    def closeEvent(self, event: QCloseEvent) -> None:
        # Call cleanup methods here
        return super().closeEvent(event)

This way you should be able to guarantee that the cleanup methods are called before the widget and any processes that it is running are destroyed.

answered May 12 '23 at 19:09

Jevex Endo

36
4

closeEvent not called when closing windows in my case – Finley May 13 '23 at 03:01
@Finley In that case could you provide some additional information on how you're closing the window? – Jevex Endo May 14 '23 at 04:11
By clicking the x button on top bar – Finley May 15 '23 at 04:31
I may have misunderstood something, is the QOpenGLWidget itself a window or is it inside a window? If it is not a window itself, then you need to overload the closeEvent of the window containing the QOpenGLWidget. – Jevex Endo May 16 '23 at 02:15
I have tried overloading `closeEvent`, not work for me. – Finley May 16 '23 at 06:58

How to decently destroy opengl resources when using QOpenGLWidget in pyqt5

1 Answers1