QGLAbstractSurface Class

 QGLPainter painter;
 painter.begin(widget);
 QGLFramebufferObjectSurface surface(fbo);
 painter.pushSurface(&surface);
 ... // draw into the fbo
 painter.popSurface();
 ... // draw into the widget

Member Function Documentation

QGLAbstractSurface::QGLAbstractSurface(int surfaceType) [protected]

Constructs an OpenGL drawing surface of the specified surfaceType.

QGLAbstractSurface::~QGLAbstractSurface() [virtual]

Destroys this OpenGL drawing surface.

bool QGLAbstractSurface::activate(QGLAbstractSurface * prevSurface = 0) [pure virtual]

Activate this surface.

If prevSurface is null, then that surface has just been deactivated in the process of switching to this surface. This may allow activate() to optimize the transition to avoid unnecessary state changes.

Typically implementations should assert if this fails in debug mode, since no rendering into the surface is possible.

See also deactivate() and switchTo().

qreal QGLAbstractSurface::aspectRatio() const [virtual]

Returns the aspect ratio of viewportGL().

The return value is used to correct perspective and orthographic projections for the aspect ratio of the drawing surface.

No adjustments are made for DPI.

Subclasses may override this function to further adjust the return value if the DPI in the horizontal vs vertical direction is not the same, that is, the pixels are not square.

QOpenGLContext * QGLAbstractSurface::context() const

Returns the OpenGL context which is associated with this surface, if any. When this surface is first activated, if this value is null then it will be set to the context current at that time.

The default value is null.

See also setContext().

QGLAbstractSurface * QGLAbstractSurface::createSurfaceForContext(QOpenGLContext * context) [static]

Creates an OpenGL drawing surface using the given context. This relies on the context having a valid surface which is a QWindow in which case the surface returned is a QGLWindowSurface.

If not, then a generic surface based on the OpenGL context is returned. In this case the generic surface will fail unless an underlying rendering surface becomes available prior to attempting to activate the surface.

void QGLAbstractSurface::deactivate(QGLAbstractSurface * nextSurface = 0) [pure virtual]

Deactivate this surface from the current context, but leave the context current. Typically this will release the framebuffer object associated with the surface.

If nextSurface is not-null, then that surface will be activated next in the process of switching away from this surface. This may allow deactivate() to optimize the transition to avoid unnecessary state changes.

See also activate() and switchTo().

QOpenGLFramebufferObject * QGLAbstractSurface::framebufferObject() const

Returns the QOpenGLFramebufferObject which is associated with this surface if any. The default value is null.

See also setFramebufferObject().

bool QGLAbstractSurface::isValid() const [virtual]

Returns true if this surface is valid and ready to be drawn into with OpenGL commands. Typically it will be true if the surface has been associated with an opengl context and a supported painting context such as a window or fbo.

Sub-class implementations can use this fall-back, which simply checks for a valid viewport rectangle.

Note that the surface may only become valid during activate() calls.

void QGLAbstractSurface::setContext(QOpenGLContext * context)

Sets the OpenGL context which is to be associated with this surface. When this surface is first activated, if this value is null then it will be set to the context current at that time.

See also context().

void QGLAbstractSurface::setFramebufferObject(QOpenGLFramebufferObject * framebufferObject)

Sets the QOpenGLFramebufferObject which is to be associated with this surface to be framebufferObject.

See also framebufferObject().

void QGLAbstractSurface::setWindow(QWindow * window)

Sets the QWindow which is to be associated with this surface to be window.

See also window().

int QGLAbstractSurface::surfaceType() const

Returns the type of this surface.

bool QGLAbstractSurface::switchTo(QGLAbstractSurface * nextSurface)

Switches from this surface to nextSurface by calling deactivate() on this surface and activate() on nextSurface.

Returns true if nextSurface was activated, or false otherwise. If nextSurface could not be activated, then this surface will remain activated.

See also activate() and deactivate().

QRect QGLAbstractSurface::viewportGL() const [pure virtual]

Returns the rectangle of the surface that is occupied by the viewport for this surface. The origin is at the bottom-left, which makes the value suitable for passing to glViewport():

 QRect viewport = surface->viewportGL();
 glViewport(viewport.x(), viewport.y(), viewport.width(), viewport.height());

Normally the viewport rectangle is the full extent of the device(), but it could be smaller if the application only wishes to draw into a subpart of the device(). An example would be rendering left and right stereo eye images into the two halves of a QGLWidget. The eye surfaces would typically be instances of QGLSubsurface.

Note that the value returned from this function is not defined before the activate() function has been called at least once.

See also viewportRect() and device().

QRect QGLAbstractSurface::viewportRect() const

Returns the rectangle of the surface device() that is occupied by the viewport for this surface. The origin is at the top-left.

This function calls viewportGL() and then flips the rectangle upside down using the height of device() so that the origin is at the top-left instead of the bottom-left.

See also viewportGL() and device().

QWindow * QGLAbstractSurface::window() const

Returns the QWindow which is associated with this surface if any. The default value is null.

See also setWindow().