Google Git
Sign in
android / platform / external / qt / 7bfefd596b628604816a01c904428ab99099b10d / . / Windows-4.7.4 / src / opengl / qwindowsurface_gl.cpp
blob: fb2743d64712063e2d566ddc2023ccd0fff20142 [file] [log] [blame]
/****************************************************************************
**
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtOpenGL module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this
** file. Please review the following information to ensure the GNU Lesser
** General Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <QtGui/QApplication>
#include <QtGui/QColormap>
#include <QtGui/QDesktopWidget>
#include <QtGui/QPaintDevice>
#include <QtGui/QWidget>
#include <qglframebufferobject.h>
#include <qglpixelbuffer.h>
#include <qcolormap.h>
#include <qdesktopwidget.h>
#include <private/qwidget_p.h>
#include "qdebug.h"
#ifdef Q_WS_X11
#include <private/qt_x11_p.h>
#include <qx11info_x11.h>
#ifndef QT_OPENGL_ES
#include <GL/glx.h>
#include <X11/Xlib.h>
#endif
#endif //Q_WS_X11
#include <private/qglextensions_p.h>
#include <private/qwindowsurface_gl_p.h>
#include <private/qgl_p.h>
#include <private/qglpixelbuffer_p.h>
#include <private/qgraphicssystem_gl_p.h>
#include <private/qpaintengineex_opengl2_p.h>
#include <private/qpixmapdata_gl_p.h>
#ifndef QT_OPENGL_ES_2
#include <private/qpaintengine_opengl_p.h>
#endif
#ifndef GLX_ARB_multisample
#define GLX_SAMPLE_BUFFERS_ARB 100000
#define GLX_SAMPLES_ARB 100001
#endif
#ifndef QT_NO_EGL
#include <private/qeglcontext_p.h>
#endif
QT_BEGIN_NAMESPACE
//
// QGLGraphicsSystem
//
#ifdef Q_WS_WIN
extern Q_GUI_EXPORT bool qt_win_owndc_required;
#endif
QGLGraphicsSystem::QGLGraphicsSystem(bool useX11GL)
: QGraphicsSystem(), m_useX11GL(useX11GL)
{
#if defined(Q_WS_X11) && !defined(QT_OPENGL_ES)
// only override the system defaults if the user hasn't already
// picked a visual
if (X11->visual == 0 && X11->visual_id == -1 && X11->visual_class == -1) {
// find a double buffered, RGBA visual that supports OpenGL
// and set that as the default visual for windows in Qt
int i = 0;
int spec[16];
spec[i++] = GLX_RGBA;
spec[i++] = GLX_DOUBLEBUFFER;
if (!qgetenv("QT_GL_SWAPBUFFER_PRESERVE").isNull()) {
spec[i++] = GLX_DEPTH_SIZE;
spec[i++] = 8;
spec[i++] = GLX_STENCIL_SIZE;
spec[i++] = 8;
spec[i++] = GLX_SAMPLE_BUFFERS_ARB;
spec[i++] = 1;
spec[i++] = GLX_SAMPLES_ARB;
spec[i++] = 4;
}
spec[i++] = XNone;
XVisualInfo *vi = glXChooseVisual(X11->display, X11->defaultScreen, spec);
if (vi) {
X11->visual_id = vi->visualid;
X11->visual_class = vi->c_class;
QGLFormat format;
int res;
glXGetConfig(X11->display, vi, GLX_LEVEL, &res);
format.setPlane(res);
glXGetConfig(X11->display, vi, GLX_DOUBLEBUFFER, &res);
format.setDoubleBuffer(res);
glXGetConfig(X11->display, vi, GLX_DEPTH_SIZE, &res);
format.setDepth(res);
if (format.depth())
format.setDepthBufferSize(res);
glXGetConfig(X11->display, vi, GLX_RGBA, &res);
format.setRgba(res);
glXGetConfig(X11->display, vi, GLX_RED_SIZE, &res);
format.setRedBufferSize(res);
glXGetConfig(X11->display, vi, GLX_GREEN_SIZE, &res);
format.setGreenBufferSize(res);
glXGetConfig(X11->display, vi, GLX_BLUE_SIZE, &res);
format.setBlueBufferSize(res);
glXGetConfig(X11->display, vi, GLX_ALPHA_SIZE, &res);
format.setAlpha(res);
if (format.alpha())
format.setAlphaBufferSize(res);
glXGetConfig(X11->display, vi, GLX_ACCUM_RED_SIZE, &res);
format.setAccum(res);
if (format.accum())
format.setAccumBufferSize(res);
glXGetConfig(X11->display, vi, GLX_STENCIL_SIZE, &res);
format.setStencil(res);
if (format.stencil())
format.setStencilBufferSize(res);
glXGetConfig(X11->display, vi, GLX_STEREO, &res);
format.setStereo(res);
glXGetConfig(X11->display, vi, GLX_SAMPLE_BUFFERS_ARB, &res);
format.setSampleBuffers(res);
if (format.sampleBuffers()) {
glXGetConfig(X11->display, vi, GLX_SAMPLES_ARB, &res);
format.setSamples(res);
}
QGLWindowSurface::surfaceFormat = format;
XFree(vi);
printf("using visual class %x, id %x\n", X11->visual_class, X11->visual_id);
}
}
#elif defined(Q_WS_WIN)
QGLWindowSurface::surfaceFormat.setDoubleBuffer(true);
qt_win_owndc_required = true;
#endif
}
//
// QGLWindowSurface
//
class QGLGlobalShareWidget
{
public:
QGLGlobalShareWidget() : widget(0), initializing(false) {}
QGLWidget *shareWidget() {
if (!initializing && !widget && !cleanedUp) {
initializing = true;
widget = new QGLWidget(QGLFormat(QGL::SingleBuffer | QGL::NoDepthBuffer | QGL::NoStencilBuffer));
widget->resize(1, 1);
// We don't need this internal widget to appear in QApplication::topLevelWidgets()
if (QWidgetPrivate::allWidgets)
QWidgetPrivate::allWidgets->remove(widget);
initializing = false;
}
return widget;
}
// destroys the share widget and prevents recreation
void cleanup() {
QGLWidget *w = widget;
cleanedUp = true;
widget = 0;
delete w;
}
// destroys the share widget, but allows it to be recreated later on
void destroy() {
if (cleanedUp)
return;
QGLWidget *w = widget;
// prevent potential recursions
cleanedUp = true;
widget = 0;
delete w;
cleanedUp = false;
}
static bool cleanedUp;
private:
QGLWidget *widget;
bool initializing;
};
bool QGLGlobalShareWidget::cleanedUp = false;
static void qt_cleanup_gl_share_widget();
Q_GLOBAL_STATIC_WITH_INITIALIZER(QGLGlobalShareWidget, _qt_gl_share_widget,
{
qAddPostRoutine(qt_cleanup_gl_share_widget);
})
static void qt_cleanup_gl_share_widget()
{
_qt_gl_share_widget()->cleanup();
}
QGLWidget* qt_gl_share_widget()
{
if (QGLGlobalShareWidget::cleanedUp)
return 0;
return _qt_gl_share_widget()->shareWidget();
}
void qt_destroy_gl_share_widget()
{
_qt_gl_share_widget()->destroy();
}
struct QGLWindowSurfacePrivate
{
QGLFramebufferObject *fbo;
QGLPixelBuffer *pb;
GLuint tex_id;
GLuint pb_tex_id;
int tried_fbo : 1;
int tried_pb : 1;
int destructive_swap_buffers : 1;
int geometry_updated : 1;
int did_paint : 1;
QGLContext *ctx;
QList<QGLContext **> contexts;
QRegion paintedRegion;
QSize size;
QSize textureSize;
QList<QImage> buffers;
QGLWindowSurfaceGLPaintDevice glDevice;
QGLWindowSurface* q_ptr;
};
QGLFormat QGLWindowSurface::surfaceFormat;
QGLWindowSurface::SwapMode QGLWindowSurface::swapBehavior = QGLWindowSurface::AutomaticSwap;
void QGLWindowSurfaceGLPaintDevice::endPaint()
{
glFlush();
QGLPaintDevice::endPaint();
}
QSize QGLWindowSurfaceGLPaintDevice::size() const
{
return d->size;
}
QGLContext* QGLWindowSurfaceGLPaintDevice::context() const
{
return d->ctx;
}
int QGLWindowSurfaceGLPaintDevice::metric(PaintDeviceMetric m) const
{
return qt_paint_device_metric(d->q_ptr->window(), m);
}
QPaintEngine *QGLWindowSurfaceGLPaintDevice::paintEngine() const
{
return qt_qgl_paint_engine();
}
QGLWindowSurface::QGLWindowSurface(QWidget *window)
: QWindowSurface(window), d_ptr(new QGLWindowSurfacePrivate)
{
Q_ASSERT(window->isTopLevel());
d_ptr->pb = 0;
d_ptr->fbo = 0;
d_ptr->ctx = 0;
d_ptr->tex_id = 0;
#if defined (QT_OPENGL_ES_2)
d_ptr->tried_fbo = true;
d_ptr->tried_pb = true;
#else
d_ptr->tried_fbo = false;
d_ptr->tried_pb = false;
#endif
d_ptr->destructive_swap_buffers = qgetenv("QT_GL_SWAPBUFFER_PRESERVE").isNull();
d_ptr->glDevice.d = d_ptr;
d_ptr->q_ptr = this;
d_ptr->geometry_updated = false;
d_ptr->did_paint = false;
#ifdef QGL_NO_PRESERVED_SWAP
setPartialUpdateSupport(false);
#endif
}
QGLWindowSurface::~QGLWindowSurface()
{
if (d_ptr->ctx)
glDeleteTextures(1, &d_ptr->tex_id);
foreach(QGLContext **ctx, d_ptr->contexts) {
delete *ctx;
*ctx = 0;
}
delete d_ptr->pb;
delete d_ptr->fbo;
delete d_ptr;
if (QGLGlobalShareWidget::cleanedUp)
return;
#ifdef Q_OS_SYMBIAN
// Destroy the context if necessary.
if (!qt_gl_share_widget()->context()->isSharing())
qt_destroy_gl_share_widget();
#endif
}
void QGLWindowSurface::deleted(QObject *object)
{
QWidget *widget = qobject_cast<QWidget *>(object);
if (widget) {
if (widget == window()) {
// Make sure that the fbo is destroyed before destroying its context.
delete d_ptr->fbo;
d_ptr->fbo = 0;
}
QWidgetPrivate *widgetPrivate = widget->d_func();
if (widgetPrivate->extraData()) {
union { QGLContext **ctxPtr; void **voidPtr; };
voidPtr = &widgetPrivate->extraData()->glContext;
int index = d_ptr->contexts.indexOf(ctxPtr);
if (index != -1) {
delete *ctxPtr;
*ctxPtr = 0;
d_ptr->contexts.removeAt(index);
}
}
}
}
void QGLWindowSurface::hijackWindow(QWidget *widget)
{
QWidgetPrivate *widgetPrivate = widget->d_func();
widgetPrivate->createExtra();
if (widgetPrivate->extraData()->glContext)
return;
QGLContext *ctx = NULL;
// For translucent top-level widgets we need alpha in the format.
if (widget->testAttribute(Qt::WA_TranslucentBackground)) {
QGLFormat modFormat(surfaceFormat);
modFormat.setSampleBuffers(false);
modFormat.setSamples(0);
modFormat.setAlpha(true);
ctx = new QGLContext(modFormat, widget);
} else
ctx = new QGLContext(surfaceFormat, widget);
ctx->create(qt_gl_share_widget()->context());
#ifndef QT_NO_EGL
static bool checkedForNOKSwapRegion = false;
static bool haveNOKSwapRegion = false;
if (!checkedForNOKSwapRegion) {
haveNOKSwapRegion = QEgl::hasExtension("EGL_NOK_swap_region2");
checkedForNOKSwapRegion = true;
if (haveNOKSwapRegion)
qDebug() << "Found EGL_NOK_swap_region2 extension. Using partial updates.";
}
bool swapBehaviourPreserved = ctx->d_func()->eglContext->configAttrib(EGL_SWAP_BEHAVIOR);
if (ctx->d_func()->eglContext->configAttrib(EGL_SURFACE_TYPE)&EGL_SWAP_BEHAVIOR_PRESERVED_BIT) {
EGLint swapBehavior;
if (eglQuerySurface(ctx->d_func()->eglContext->display(), ctx->d_func()->eglSurface
, EGL_SWAP_BEHAVIOR, &swapBehavior)) {
swapBehaviourPreserved = (swapBehavior == EGL_BUFFER_PRESERVED);
}
}
if (!swapBehaviourPreserved && !haveNOKSwapRegion)
setPartialUpdateSupport(false); // Force full-screen updates
else
setPartialUpdateSupport(true);
#endif
widgetPrivate->extraData()->glContext = ctx;
union { QGLContext **ctxPtr; void **voidPtr; };
connect(widget, SIGNAL(destroyed(QObject*)), this, SLOT(deleted(QObject*)));
voidPtr = &widgetPrivate->extraData()->glContext;
d_ptr->contexts << ctxPtr;
#ifndef Q_OS_SYMBIAN
qDebug() << "hijackWindow() context created for" << widget << d_ptr->contexts.size();
#endif
}
QGLContext *QGLWindowSurface::context() const
{
return d_ptr->ctx;
}
QPaintDevice *QGLWindowSurface::paintDevice()
{
updateGeometry();
if (d_ptr->pb)
return d_ptr->pb;
if (d_ptr->ctx)
return &d_ptr->glDevice;
QGLContext *ctx = reinterpret_cast<QGLContext *>(window()->d_func()->extraData()->glContext);
ctx->makeCurrent();
Q_ASSERT(d_ptr->fbo);
return d_ptr->fbo;
}
static void drawTexture(const QRectF &rect, GLuint tex_id, const QSize &texSize, const QRectF &src = QRectF());
void QGLWindowSurface::beginPaint(const QRegion &)
{
updateGeometry();
if (!context())
return;
int clearFlags = 0;
if (context()->d_func()->workaround_needsFullClearOnEveryFrame)
clearFlags = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
else if (context()->format().alpha())
clearFlags = GL_COLOR_BUFFER_BIT;
if (clearFlags) {
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(clearFlags);
}
d_ptr->did_paint = true;
}
void QGLWindowSurface::endPaint(const QRegion &rgn)
{
if (context())
d_ptr->paintedRegion |= rgn;
d_ptr->buffers.clear();
}
static void blitTexture(QGLContext *ctx, GLuint texture, const QSize &viewport, const QSize &texSize, const QRect &targetRect, const QRect &sourceRect)
{
glDisable(GL_DEPTH_TEST);
glDisable(GL_SCISSOR_TEST);
glDisable(GL_BLEND);
glViewport(0, 0, viewport.width(), viewport.height());
QGLShaderProgram *blitProgram =
QGLEngineSharedShaders::shadersForContext(ctx)->blitProgram();
blitProgram->bind();
blitProgram->setUniformValue("imageTexture", 0 /*QT_IMAGE_TEXTURE_UNIT*/);
// The shader manager's blit program does not multiply the
// vertices by the pmv matrix, so we need to do the effect
// of the orthographic projection here ourselves.
QRectF r;
qreal w = viewport.width();
qreal h = viewport.height();
r.setLeft((targetRect.left() / w) * 2.0f - 1.0f);
if (targetRect.right() == (viewport.width() - 1))
r.setRight(1.0f);
else
r.setRight((targetRect.right() / w) * 2.0f - 1.0f);
r.setBottom((targetRect.top() / h) * 2.0f - 1.0f);
if (targetRect.bottom() == (viewport.height() - 1))
r.setTop(1.0f);
else
r.setTop((targetRect.bottom() / w) * 2.0f - 1.0f);
drawTexture(r, texture, texSize, sourceRect);
}
void QGLWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)
{
//### Find out why d_ptr->geometry_updated isn't always false.
// flush() should not be called when d_ptr->geometry_updated is true. It assumes that either
// d_ptr->fbo or d_ptr->pb is allocated and has the correct size.
if (d_ptr->geometry_updated)
return;
// did_paint is set to true in ::beginPaint. ::beginPaint means that we
// at least cleared the background (= painted something). In EGL API it's a
// mistake to call swapBuffers if nothing was painted unless
// EGL_BUFFER_PRESERVED is set. This check protects the flush func from
// being executed if it's for nothing.
if (!hasPartialUpdateSupport() && !d_ptr->did_paint)
return;
#ifdef Q_OS_SYMBIAN
if (window() != widget) {
// For performance reasons we don't support
// flushing native child widgets on Symbian.
// It breaks overlapping native child widget
// rendering in some cases but we prefer performance.
return;
}
#endif
QWidget *parent = widget->internalWinId() ? widget : widget->nativeParentWidget();
Q_ASSERT(parent);
if (!geometry().isValid())
return;
// Needed to support native child-widgets...
hijackWindow(parent);
QRect br = rgn.boundingRect().translated(offset);
br = br.intersected(window()->rect());
QPoint wOffset = qt_qwidget_data(parent)->wrect.topLeft();
QRect rect = br.translated(-offset - wOffset);
const GLenum target = GL_TEXTURE_2D;
Q_UNUSED(target);
if (QGLWindowSurface::swapBehavior == QGLWindowSurface::KillSwap)
return;
if (context()) {
context()->makeCurrent();
if (context()->format().doubleBuffer()) {
#if !defined(QT_OPENGL_ES_2)
if (d_ptr->destructive_swap_buffers) {
glBindTexture(target, d_ptr->tex_id);
QVector<QRect> rects = d_ptr->paintedRegion.rects();
for (int i = 0; i < rects.size(); ++i) {
QRect br = rects.at(i);
if (br.isEmpty())
continue;
const uint bottom = window()->height() - (br.y() + br.height());
glCopyTexSubImage2D(target, 0, br.x(), bottom, br.x(), bottom, br.width(), br.height());
}
glBindTexture(target, 0);
QRegion dirtyRegion = QRegion(window()->rect()) - d_ptr->paintedRegion;
if (!dirtyRegion.isEmpty()) {
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
#ifndef QT_OPENGL_ES
glOrtho(0, window()->width(), window()->height(), 0, -999999, 999999);
#else
glOrthof(0, window()->width(), window()->height(), 0, -999999, 999999);
#endif
glViewport(0, 0, window()->width(), window()->height());
QVector<QRect> rects = dirtyRegion.rects();
glColor4f(1, 1, 1, 1);
for (int i = 0; i < rects.size(); ++i) {
QRect rect = rects.at(i);
if (rect.isEmpty())
continue;
drawTexture(rect, d_ptr->tex_id, window()->size(), rect);
}
}
}
#endif
bool doingPartialUpdate = false;
if (QGLWindowSurface::swapBehavior == QGLWindowSurface::AutomaticSwap)
doingPartialUpdate = hasPartialUpdateSupport() && br.width() * br.height() < parent->geometry().width() * parent->geometry().height() * 0.2;
else if (QGLWindowSurface::swapBehavior == QGLWindowSurface::AlwaysFullSwap)
doingPartialUpdate = false;
else if (QGLWindowSurface::swapBehavior == QGLWindowSurface::AlwaysPartialSwap)
doingPartialUpdate = hasPartialUpdateSupport();
QGLContext *ctx = reinterpret_cast<QGLContext *>(parent->d_func()->extraData()->glContext);
if (widget != window()) {
if (initializeOffscreenTexture(window()->size()))
qWarning() << "QGLWindowSurface: Flushing to native child widget, may lead to significant performance loss";
glBindTexture(target, d_ptr->tex_id);
const uint bottom = window()->height() - (br.y() + br.height());
glCopyTexSubImage2D(target, 0, br.x(), bottom, br.x(), bottom, br.width(), br.height());
glBindTexture(target, 0);
ctx->makeCurrent();
if (doingPartialUpdate)
blitTexture(ctx, d_ptr->tex_id, parent->size(), window()->size(), rect, br);
else
blitTexture(ctx, d_ptr->tex_id, parent->size(), window()->size(), parent->rect(), parent->rect().translated(offset + wOffset));
}
if (doingPartialUpdate)
ctx->d_func()->swapRegion(br);
else
ctx->swapBuffers();
d_ptr->paintedRegion = QRegion();
} else {
glFlush();
}
return;
}
QGLContext *previous_ctx = const_cast<QGLContext *>(QGLContext::currentContext());
QGLContext *ctx = reinterpret_cast<QGLContext *>(parent->d_func()->extraData()->glContext);
// QPainter::end() should have unbound the fbo, otherwise something is very wrong...
Q_ASSERT(!d_ptr->fbo || !d_ptr->fbo->isBound());
if (ctx != previous_ctx) {
ctx->makeCurrent();
}
QSize size = widget->rect().size();
if (d_ptr->destructive_swap_buffers && ctx->format().doubleBuffer()) {
rect = parent->rect();
br = rect.translated(wOffset + offset);
size = parent->size();
}
glDisable(GL_SCISSOR_TEST);
if (d_ptr->fbo && (QGLExtensions::glExtensions() & QGLExtensions::FramebufferBlit)) {
const int h = d_ptr->fbo->height();
const int sx0 = br.left();
const int sx1 = br.left() + br.width();
const int sy0 = h - (br.top() + br.height());
const int sy1 = h - br.top();
const int tx0 = rect.left();
const int tx1 = rect.left() + rect.width();
const int ty0 = parent->height() - (rect.top() + rect.height());
const int ty1 = parent->height() - rect.top();
if (window() == parent || d_ptr->fbo->format().samples() <= 1) {
if (ctx->d_ptr->current_fbo != 0)
glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, 0);
glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, d_ptr->fbo->handle());
glBlitFramebufferEXT(sx0, sy0, sx1, sy1,
tx0, ty0, tx1, ty1,
GL_COLOR_BUFFER_BIT,
GL_NEAREST);
glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, 0);
} else {
#ifndef Q_OS_SYMBIAN // We don't have FBO pool on Symbian
// can't do sub-region blits with multisample FBOs
QGLFramebufferObject *temp = qgl_fbo_pool()->acquire(d_ptr->fbo->size(), QGLFramebufferObjectFormat());
glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, temp->handle());
glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, d_ptr->fbo->handle());
glBlitFramebufferEXT(0, 0, d_ptr->fbo->width(), d_ptr->fbo->height(),
0, 0, d_ptr->fbo->width(), d_ptr->fbo->height(),
GL_COLOR_BUFFER_BIT,
GL_NEAREST);
glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, temp->handle());
glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, 0);
glBlitFramebufferEXT(sx0, sy0, sx1, sy1,
tx0, ty0, tx1, ty1,
GL_COLOR_BUFFER_BIT,
GL_NEAREST);
glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, 0);
qgl_fbo_pool()->release(temp);
#endif // Q_OS_SYMBIAN
}
ctx->d_ptr->current_fbo = 0;
}
#if !defined(QT_OPENGL_ES_2)
else {
GLuint texture;
if (d_ptr->fbo) {
texture = d_ptr->fbo->texture();
} else {
d_ptr->pb->makeCurrent();
glBindTexture(target, d_ptr->pb_tex_id);
const uint bottom = window()->height() - (br.y() + br.height());
glCopyTexSubImage2D(target, 0, br.x(), bottom, br.x(), bottom, br.width(), br.height());
texture = d_ptr->pb_tex_id;
glBindTexture(target, 0);
}
glDisable(GL_DEPTH_TEST);
if (d_ptr->fbo) {
d_ptr->fbo->release();
} else {
ctx->makeCurrent();
}
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
#ifndef QT_OPENGL_ES
glOrtho(0, size.width(), size.height(), 0, -999999, 999999);
#else
glOrthof(0, size.width(), size.height(), 0, -999999, 999999);
#endif
glViewport(0, 0, size.width(), size.height());
glColor4f(1, 1, 1, 1);
drawTexture(rect, texture, window()->size(), br);
if (d_ptr->fbo)
d_ptr->fbo->bind();
}
#else
// OpenGL/ES 2.0 version of the fbo blit.
else if (d_ptr->fbo) {
Q_UNUSED(target);
if (d_ptr->fbo->isBound())
d_ptr->fbo->release();
blitTexture(ctx, d_ptr->fbo->texture(), size, window()->size(), rect, br);
}
#endif
if (ctx->format().doubleBuffer())
ctx->swapBuffers();
else
glFlush();
d_ptr->did_paint = false;
}
void QGLWindowSurface::setGeometry(const QRect &rect)
{
QWindowSurface::setGeometry(rect);
d_ptr->geometry_updated = true;
}
void QGLWindowSurface::updateGeometry() {
if (!d_ptr->geometry_updated)
return;
d_ptr->geometry_updated = false;
bool hijack(true);
QWidgetPrivate *wd = window()->d_func();
if (wd->extraData() && wd->extraData()->glContext) {
#ifdef Q_OS_SYMBIAN // Symbian needs to recreate the context when native window size changes
if (d_ptr->size != geometry().size()) {
QGLContext *ctx = reinterpret_cast<QGLContext *>(wd->extraData()->glContext);
if (ctx == QGLContext::currentContext())
ctx->doneCurrent();
ctx->d_func()->destroyEglSurfaceForDevice();
// Delete other contexts (shouldn't happen too often, if at all)
while (d_ptr->contexts.size()) {
QGLContext **ctxPtrPtr = d_ptr->contexts.takeFirst();
if ((*ctxPtrPtr) != ctx)
delete *ctxPtrPtr;
}
union { QGLContext **ctxPtrPtr; void **voidPtrPtr; };
voidPtrPtr = &wd->extraData()->glContext;
d_ptr->contexts << ctxPtrPtr;
ctx->d_func()->eglSurface = ctx->d_func()->eglContext->createSurface(window());
// Partial update supported has been decided already in previous hijackWindow call.
// Reset swap behaviour based on that flag.
if (hasPartialUpdateSupport()) {
eglSurfaceAttrib(QEgl::display(), ctx->d_func()->eglSurfaceForDevice(),
EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED);
if (eglGetError() != EGL_SUCCESS)
qWarning("QGLWindowSurface::updateGeometry() - could not re-enable preserved swap behaviour");
} else {
eglSurfaceAttrib(QEgl::display(), ctx->d_func()->eglSurfaceForDevice(),
EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED);
if (eglGetError() != EGL_SUCCESS)
qWarning("QGLWindowSurface::updateGeometry() - could not re-enable destroyed swap behaviour");
}
}
#endif
hijack = false; // we already have gl context for widget
}
if (hijack)
hijackWindow(window());
QGLContext *ctx = reinterpret_cast<QGLContext *>(wd->extraData()->glContext);
#ifdef Q_WS_MAC
ctx->updatePaintDevice();
#endif
QSize surfSize = geometry().size();
if (surfSize.width() <= 0 || surfSize.height() <= 0)
return;
if (d_ptr->size == surfSize)
return;
d_ptr->size = surfSize;
if (d_ptr->ctx) {
#ifndef QT_OPENGL_ES_2
if (d_ptr->destructive_swap_buffers)
initializeOffscreenTexture(surfSize);
#endif
return;
}
const GLenum target = GL_TEXTURE_2D;
if (d_ptr->destructive_swap_buffers
&& (QGLExtensions::glExtensions() & QGLExtensions::FramebufferObject)
&& (d_ptr->fbo || !d_ptr->tried_fbo)
&& qt_gl_preferGL2Engine())
{
d_ptr->tried_fbo = true;
ctx->d_ptr->internal_context = true;
ctx->makeCurrent();
delete d_ptr->fbo;
QGLFramebufferObjectFormat format;
format.setAttachment(QGLFramebufferObject::CombinedDepthStencil);
format.setInternalTextureFormat(GLenum(GL_RGBA));
format.setTextureTarget(target);
if (QGLExtensions::glExtensions() & QGLExtensions::FramebufferBlit)
format.setSamples(8);
d_ptr->fbo = new QGLFramebufferObject(surfSize, format);
if (d_ptr->fbo->isValid()) {
qDebug() << "Created Window Surface FBO" << surfSize
<< "with samples" << d_ptr->fbo->format().samples();
return;
} else {
qDebug() << "QGLWindowSurface: Failed to create valid FBO, falling back";
delete d_ptr->fbo;
d_ptr->fbo = 0;
}
}
#if !defined(QT_OPENGL_ES_2)
if (d_ptr->destructive_swap_buffers && (d_ptr->pb || !d_ptr->tried_pb)) {
d_ptr->tried_pb = true;
if (d_ptr->pb) {
d_ptr->pb->makeCurrent();
glDeleteTextures(1, &d_ptr->pb_tex_id);
}
delete d_ptr->pb;
d_ptr->pb = new QGLPixelBuffer(surfSize.width(), surfSize.height(),
QGLFormat(QGL::SampleBuffers | QGL::StencilBuffer | QGL::DepthBuffer),
qt_gl_share_widget());
if (d_ptr->pb->isValid()) {
qDebug() << "Created Window Surface Pixelbuffer, Sample buffers:" << d_ptr->pb->format().sampleBuffers();
d_ptr->pb->makeCurrent();
glGenTextures(1, &d_ptr->pb_tex_id);
glBindTexture(target, d_ptr->pb_tex_id);
glTexImage2D(target, 0, GL_RGBA, surfSize.width(), surfSize.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glBindTexture(target, 0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, d_ptr->pb->width(), d_ptr->pb->height(), 0, -999999, 999999);
d_ptr->pb->d_ptr->qctx->d_func()->internal_context = true;
return;
} else {
qDebug() << "QGLWindowSurface: Failed to create valid pixelbuffer, falling back";
delete d_ptr->pb;
d_ptr->pb = 0;
}
}
#endif // !defined(QT_OPENGL_ES_2)
ctx->makeCurrent();
#ifndef QT_OPENGL_ES_2
if (d_ptr->destructive_swap_buffers)
initializeOffscreenTexture(surfSize);
#endif
#ifndef Q_OS_SYMBIAN
qDebug() << "QGLWindowSurface: Using plain widget as window surface" << this;
#endif
d_ptr->ctx = ctx;
d_ptr->ctx->d_ptr->internal_context = true;
}
bool QGLWindowSurface::initializeOffscreenTexture(const QSize &size)
{
if (size == d_ptr->textureSize)
return false;
glGenTextures(1, &d_ptr->tex_id);
glBindTexture(GL_TEXTURE_2D, d_ptr->tex_id);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, size.width(), size.height(), 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, 0);
d_ptr->textureSize = size;
return true;
}
bool QGLWindowSurface::scroll(const QRegion &area, int dx, int dy)
{
// this code randomly fails currently for unknown reasons
return false;
if (!d_ptr->pb)
return false;
d_ptr->pb->makeCurrent();
QRect br = area.boundingRect();
#if 0
// ## workaround driver issue (scrolling by these deltas is unbearably slow for some reason)
// ## maybe we should use glCopyTexSubImage insteadk
if (dx == 1 || dx == -1 || dy == 1 || dy == -1 || dy == 2)
return false;
glRasterPos2i(br.x() + dx, br.y() + br.height() + dy);
glCopyPixels(br.x(), d_ptr->pb->height() - (br.y() + br.height()), br.width(), br.height(), GL_COLOR);
return true;
#endif
const GLenum target = GL_TEXTURE_2D;
glBindTexture(target, d_ptr->tex_id);
glCopyTexImage2D(target, 0, GL_RGBA, br.x(), d_ptr->pb->height() - (br.y() + br.height()), br.width(), br.height(), 0);
glBindTexture(target, 0);
drawTexture(br.translated(dx, dy), d_ptr->tex_id, window()->size());
return true;
}
static void drawTexture(const QRectF &rect, GLuint tex_id, const QSize &texSize, const QRectF &br)
{
const GLenum target = GL_TEXTURE_2D;
QRectF src = br.isEmpty()
? QRectF(QPointF(), texSize)
: QRectF(QPointF(br.x(), texSize.height() - br.bottom()), br.size());
if (target == GL_TEXTURE_2D) {
qreal width = texSize.width();
qreal height = texSize.height();
src.setLeft(src.left() / width);
src.setRight(src.right() / width);
src.setTop(src.top() / height);
src.setBottom(src.bottom() / height);
}
const GLfloat tx1 = src.left();
const GLfloat tx2 = src.right();
const GLfloat ty1 = src.top();
const GLfloat ty2 = src.bottom();
GLfloat texCoordArray[4*2] = {
tx1, ty2, tx2, ty2, tx2, ty1, tx1, ty1
};
GLfloat vertexArray[4*2];
extern void qt_add_rect_to_array(const QRectF &r, GLfloat *array); // qpaintengine_opengl.cpp
qt_add_rect_to_array(rect, vertexArray);
#if !defined(QT_OPENGL_ES_2)
glVertexPointer(2, GL_FLOAT, 0, vertexArray);
glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
glBindTexture(target, tex_id);
glEnable(target);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(target);
glBindTexture(target, 0);
#else
glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, vertexArray);
glVertexAttribPointer(QT_TEXTURE_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, texCoordArray);
glBindTexture(target, tex_id);
glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
glEnableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glDisableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
glDisableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
glBindTexture(target, 0);
#endif
}
QImage *QGLWindowSurface::buffer(const QWidget *widget)
{
QImage image;
if (d_ptr->pb)
image = d_ptr->pb->toImage();
else if (d_ptr->fbo)
image = d_ptr->fbo->toImage();
if (image.isNull())
return 0;
QRect rect = widget->rect();
rect.translate(widget->mapTo(widget->window(), QPoint()));
QImage subImage = image.copy(rect);
d_ptr->buffers << subImage;
return &d_ptr->buffers.last();
}
QT_END_NAMESPACE