Creates a new OpenGL context with the given parent. Before the context can be used call setFormat() and then create().

See also

create(), makeCurrent()

Destroys the QOpenGLContext object. If this QOpenGLContext is active for the current thread then doneCurrent() will be called.

Attempts to create the OpenGL context with the current configuration. The current configuration includes the format, the share context, and the screen. Returns true if the native context was successfully created and is ready to be used with makeCurrent(), swapBuffers(), etc.

If the OpenGL implementation on your system does not support the requested version of OpenGL context, then QOpenGLContext will try to create the closest matching version. The actual created context properties can be queried using the QSurfaceFormat returned by the format() function. For example, if you request a context that supports OpenGL 4.3 Core profile but the driver and/or hardware only supports version 3.2 Core profile contexts then you will get a 3.2 Core profile context.

If the context already exists, this method destroys the existing context first and then creates a new one.

See also

format(), makeCurrent()

Returns the last context which called makeCurrent() in the current thread or a nullptr if no context is active.

This method returns the default framebuffer object for the current surface.

On some platforms the default framebuffer object depends on the surface being rendered to and might not have an index of 0. Instead of calling glBindFramebuffer(0) call glBindFramebuffer(ctx->defaultFramebufferObject()). If you use the glBindFramebuffer() in QOpenGLFunctions the context frame buffer object will be set correctly.

Note

Widgets which render via framebuffer objects like QOpenGLWidget will override the value returned from this method when painting is active. At that time the correct "default" framebuffer is the widget's associated backing framebuffer, not the platform specific one belonging to the top-level window's surface. This ensures the expected behavior for this method and other classes relying on it.

See also

QOpenGLFramebufferObject

Equivalent to calling makeCurrent() with a null surface. Calling this method results in no context being current in the current thread.

See also

currentContext()

Returns the set of OpenGL extensions supported by this context. The context or a sharing context must be current.

See also

hasExtension()

Returns the QOpenGLExtraFunctions instance for this context. QOpenGLContext offers this as a convenient way to access QOpenGLExtraFunctions without having to manage it manually. The context or a sharing context must be current. The returned QOpenGLExtraFunctions instance is ready to be used and it does not need initializeOpenGLFunctions() to be called.

Note

QOpenGLExtraFunctions contains functionality that is not guaranteed to be available at runtime. Runtime availability depends on the platform, graphics driver, and the OpenGL version requested by the application.

See also

QOpenGLFunctions, QOpenGLExtraFunctions

Returns the format of the underlying platform context, if create() has been called. Otherwise, returns the requested format.

The requested and the actual format may differ. Requesting a given OpenGL version does not mean the resulting context will target exactly the requested version. It is only guaranteed that the version/profile/options combination for the created context is compatible with the request, as long as the driver is able to provide such a context.

For example, requesting an OpenGL version 3.x core profile context may result in an OpenGL 4.x core profile context. Similarly, a request for OpenGL 2.1 may result in an OpenGL 3.0 context with deprecated functions enabled. Finally, depending on the driver, unsupported versions may result in either a context creation failure or in a context for the highest supported version.

Similar differences are possible in the buffer sizes, for example, the resulting context may have a larger depth buffer than requested.

See also

setFormat()

Get the QOpenGLFunctions instance for this context. QOpenGLContext offers this as a convenient way to access QOpenGLFunctions without having to manage it manually. The context or a sharing context must be current. The returned QOpenGLFunctions instance is ready to be used and it does not need initializeOpenGLFunctions() to be called.

Returns the shared OpenGL context for the application, if one is available. Otherwise, returns a nullptr. This is useful if you need to upload OpenGL objects (buffers, textures, etc.) before creating or showing a QOpenGLWidget.

You must set the Qt::AA_ShareOpenGLContexts flag on QApplication before creating the QApplication object, otherwise CopperSpice may not create a global shared context.

Warning

Do not attempt to make the context returned by this method current on any surface. Instead, create a new context which shares with the global one and then make the new context current.

See also

setShareContext(), makeCurrent()

Returns true if this OpenGL context supports the specified OpenGL extension, otherwise returns false. The context or a sharing context must be current.

See also

extensions()

Returns true if the context is an OpenGL ES context. If the context has not yet been created, the result is based on the requested format set via setFormat().

See also

create(), format(), setFormat()

Sets the current context in the current thread to render to the given surface. Returns true if successful otherwise returns false. The latter may happen if the surface is not exposed or the graphics hardware is not available due to the application being suspended.

If surface is a nullptr then calling this method is equivalent to calling doneCurrent().

Avoid calling this method from a different thread than the one the QOpenGLContext instance lives in. If you wish to use QOpenGLContext from a different thread you should first make sure it's not current in the current thread, by calling doneCurrent() if necessary. Then call moveToThread(otherThread) before using it in the other thread.

See also

functions(), doneCurrent()

Returns the underlying OpenGL implementation type. On platforms where the OpenGL implementation is not dynamically loaded, the return value is determined during compile time and never changes.

A desktop OpenGL implementation may be capable of creating ES-compatible contexts too. Therefore in most cases it is more appropriate to check QSurfaceFormat::renderableType() or use the method isOpenGLES().

This method can only be called after a QApplication has been created.

Returns the screen this context is displayed on.

See also

setScreen()

Sets the format the OpenGL context should be compatible with. Call create() so the new format will take effect.

When the format is not explicitly set via this function, the format returned by QSurfaceFormat::defaultFormat() will be used. This means that when having multiple contexts, individual calls to this function can be replaced by one single call to QSurfaceFormat::setDefaultFormat() before creating the first context.

See also

format()

Sets the screen this context will be displayed on.

See also

screen()

Configures this context to share textures, shaders, and other OpenGL resources with the given shareContext.

See also

shareContext()

Returns the share context this context was created with. If the underlying platform was not able to support the requested sharing this method will return a nullptr.

See also

setShareContext()

Returns the share group this context belongs to.