This enum describes the update strategy of the QOpenGLWindow.

Constructs a new QOpenGLWindow with the given parent and updateBehavior.

See also

QOpenGLWindow::UpdateBehavior

Constructs a new QOpenGLWindow with the given parent and updateBehavior. The QOpenGLWindow's context will share with shareContext.

See also

shareContext(), QOpenGLWindow::UpdateBehavior

Destroys this QOpenGLWindow and frees all resources. The OpenGLWindow's context is made current in the destructor allowing for safe destruction of any child object that may need to release OpenGL resources belonging to the context provided by this window.

Warning

If you have objects wrapping OpenGL resources (such as QOpenGLBuffer, QOpenGLShaderProgram, etc.) as members of a QOpenGLWindow subclass you may need to add a call to makeCurrent() in that subclass destructor as well. The child class destructors will be invoked before destroying this base class.

See also

makeCurrent()

Returns the QOpenGLContext used by this window or a nullptr if it is not initialized.

The framebuffer object handle used by this window. When the update behavior is set to NoPartialUpdate, there is no separate framebuffer object. In this case the returned value is the ID of the default framebuffer. Otherwise the value of the ID of the framebuffer object or 0 if not yet initialized.

Releases the context. It is not necessary to call this method in most cases, since the widget will make sure the context is bound and released properly when invoking paintGL().

See also

makeCurrent()

This signal is emitted after the potentially blocking buffer swap has been done. Applications that wish to continuously repaint synchronized to the vertical refresh, should issue an update() upon this signal. This allows for a much smoother experience compared to the traditional usage of timers.

Returns a copy of the framebuffer.

Called once before the first call to paintGL() or resizeGL(). his method must be reimplement in a subclass.

This method should set up any required OpenGL resources and state. There is no need to call makeCurrent() because this has already been done when this function is called. Note however that the framebuffer, in case partial update mode is used, is not yet available at this stage, so avoid issuing draw calls from here. Defer such calls to paintGL() instead.

See also

paintGL(), resizeGL()

Returns true if the window's OpenGL resources, like the context, have been successfully initialized. The return value is always false until the window becomes exposed or shown.

Prepares for rendering OpenGL content for this window by making the corresponding context current and binding the framebuffer object, if there is one in that context.

It is not necessary to call this method in most cases, because it is called automatically before invoking paintGL(). It is provided nonetheless to support advanced, multi-threaded scenarios where a thread different than the GUI or main thread may want to update the surface or framebuffer contents. Refer to QOpenGLContext for more information on threading related issues.

This method is suitable for calling also when the underlying platform window is already destroyed. This means that it is safe to call this method from a QOpenGLWindow subclass' destructor. If there is no native window anymore, an offscreen surface is used instead. This ensures that OpenGL resource cleanup operations in the destructor will always work, as long as this method is called first.

See also

QOpenGLContext, context(), doneCurrent(), paintGL()

Reimplemented from QPaintDevice::metric()

This event handler will call paintGL().

Reimplemented from QPaintDeviceWindow::paintEvent()

Called any time the window contents needs to be painted. This method must be reimplement in a subclass.

There is no need to call makeCurrent() because this has already been done when this method is called. Before invoking this method the context and the framebuffer, if there is one, are bound, and the viewport is set up by a call to glViewport(). No other state is set and no clearing or drawing is performed by the framework.

When using a partial update behavior, like PartialUpdateBlend, the output of the previous paintGL() call is preserved and, after the additional drawing performed in the current invocation of the method, the content is blitted or blended over the content drawn directly to the window in paintUnderGL().

See also

initializeGL(), resizeGL(), paintUnderGL(), paintOverGL(), QOpenGLWindow::UpdateBehavior

Called after each invocation of paintGL(). When the update mode is set to NoPartialUpdate, there is no difference between this function and paintGL(), performing rendering in either of them leads to the same result.

Like paintUnderGL(), rendering in this method targets the default framebuffer of the window, regardless of the update behavior. It gets called after paintGL() has returned and the blit (PartialUpdateBlit) or quad drawing (PartialUpdateBlend) has been done.

See also

paintGL(), paintUnderGL(), QOpenGLWindow::UpdateBehavior

Called before each invocation of paintGL(). When the update mode is set to NoPartialUpdate, there is no difference between this function and paintGL(), performing rendering in either of them leads to the same result.

The difference becomes significant when using PartialUpdateBlend, where an extra framebuffer object is used. There, paintGL() targets this additional framebuffer object, which preserves its contents, while paintUnderGL() and paintOverGL() target the default framebuffer, i.e. directly the window surface, the contents of which is lost after each displayed frame.

Avoid relying on this method when the update behavior is PartialUpdateBlit. This mode involves blitting the extra framebuffer used by paintGL() onto the default framebuffer after each invocation of paintGL(), thus overwriting all drawing generated in this function.

See also

paintGL(), paintOverGL(), QOpenGLWindow::UpdateBehavior

Called any time the widget has been resized. This method must be reimplement in a subclass. The new size is passed in w and h.

This method is for convenience to provide an API which is compatible with QOpenGLWidget. Unlike with QOpenGLWidget, derived classes are free to choose to override resizeEvent() instead of this method. Avoid issuing OpenGL commands from this method as there may not be a context current when it is invoked. If it cannot be avoided, call makeCurrent(). Scheduling updates from here is not necessary. The windowing systems will send expose events that trigger an update automatically.

See also

initializeGL(), paintGL()

Returns the QOpenGLContext requested to be shared with the current QOpenGLContext.

Returns the update behavior for the current QOpenGLWindow.