src/opengl/qwindowsurface_gl.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the QtOpenGL module of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** GNU Lesser General Public License Usage
  11 ** This file may be used under the terms of the GNU Lesser General Public
  12 ** License version 2.1 as published by the Free Software Foundation and
  13 ** appearing in the file LICENSE.LGPL included in the packaging of this
  14 ** file. Please review the following information to ensure the GNU Lesser
  15 ** General Public License version 2.1 requirements will be met:
  16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  17 **
  18 ** In addition, as a special exception, Nokia gives you certain additional
  19 ** rights. These rights are described in the Nokia Qt LGPL Exception
  20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  21 **
  22 ** GNU General Public License Usage
  23 ** Alternatively, this file may be used under the terms of the GNU General
  24 ** Public License version 3.0 as published by the Free Software Foundation
  25 ** and appearing in the file LICENSE.GPL included in the packaging of this
  26 ** file. Please review the following information to ensure the GNU General
  27 ** Public License version 3.0 requirements will be met:
  28 ** http://www.gnu.org/copyleft/gpl.html.
  29 **
  30 ** Other Usage
  31 ** Alternatively, this file may be used in accordance with the terms and
  32 ** conditions contained in a signed written agreement between you and Nokia.
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include <QtGui/QApplication>
  43 #include <QtGui/QColormap>
  44 #include <QtGui/QDesktopWidget>
  45 #include <QtGui/QPaintDevice>
  46 #include <QtGui/QWidget>
  47
  48 #include <qglframebufferobject.h>
  49 #include <qglpixelbuffer.h>
  50 #include <qcolormap.h>
  51 #include <qdesktopwidget.h>
  52 #include <private/qwidget_p.h>
  53 #include "qdebug.h"
  54
  55 #ifdef Q_WS_X11
  56 #include <private/qt_x11_p.h>
  57 #include <qx11info_x11.h>
  58
  59 #ifndef QT_OPENGL_ES
  60 #include <GL/glx.h>
  61 #include <X11/Xlib.h>
  62 #endif
  63 #endif //Q_WS_X11
  64
  65 #include <private/qglextensions_p.h>
  66 #include <private/qwindowsurface_gl_p.h>
  67
  68 #include <private/qgl_p.h>
  69
  70 #include <private/qglpixelbuffer_p.h>
  71 #include <private/qgraphicssystem_gl_p.h>
  72
  73 #include <private/qpaintengineex_opengl2_p.h>
  74 #include <private/qpixmapdata_gl_p.h>
  75
  76 #ifndef QT_OPENGL_ES_2
  77 #include <private/qpaintengine_opengl_p.h>
  78 #endif
  79
  80 #ifndef GLX_ARB_multisample
  81 #define GLX_SAMPLE_BUFFERS_ARB  100000
  82 #define GLX_SAMPLES_ARB         100001
  83 #endif
  84
  85 #ifndef QT_NO_EGL
  86 #include <private/qeglcontext_p.h>
  87 #endif
  88
  89 QT_BEGIN_NAMESPACE
  90
  91 //
  92 // QGLGraphicsSystem
  93 //
  94 #ifdef Q_WS_WIN
  95 extern Q_GUI_EXPORT bool qt_win_owndc_required;
  96 #endif
  97 QGLGraphicsSystem::QGLGraphicsSystem(bool useX11GL)
  98     : QGraphicsSystem(), m_useX11GL(useX11GL)
  99 {
 100 #if defined(Q_WS_X11) && !defined(QT_OPENGL_ES)
 101     // only override the system defaults if the user hasn't already
 102     // picked a visual
 103     if (X11->visual == 0 && X11->visual_id == -1 && X11->visual_class == -1) {
 104         // find a double buffered, RGBA visual that supports OpenGL
 105         // and set that as the default visual for windows in Qt
 106         int i = 0;
 107         int spec[16];
 108         spec[i++] = GLX_RGBA;
 109         spec[i++] = GLX_DOUBLEBUFFER;
 110
 111         if (!qgetenv("QT_GL_SWAPBUFFER_PRESERVE").isNull()) {
 112             spec[i++] = GLX_DEPTH_SIZE;
 113             spec[i++] = 8;
 114             spec[i++] = GLX_STENCIL_SIZE;
 115             spec[i++] = 8;
 116             spec[i++] = GLX_SAMPLE_BUFFERS_ARB;
 117             spec[i++] = 1;
 118             spec[i++] = GLX_SAMPLES_ARB;
 119             spec[i++] = 4;
 120         }
 121
 122         spec[i++] = XNone;
 123
 124         XVisualInfo *vi = glXChooseVisual(X11->display, X11->defaultScreen, spec);
 125         if (vi) {
 126             X11->visual_id = vi->visualid;
 127             X11->visual_class = vi->c_class;
 128
 129             QGLFormat format;
 130             int res;
 131             glXGetConfig(X11->display, vi, GLX_LEVEL, &res);
 132             format.setPlane(res);
 133             glXGetConfig(X11->display, vi, GLX_DOUBLEBUFFER, &res);
 134             format.setDoubleBuffer(res);
 135             glXGetConfig(X11->display, vi, GLX_DEPTH_SIZE, &res);
 136             format.setDepth(res);
 137             if (format.depth())
 138                 format.setDepthBufferSize(res);
 139             glXGetConfig(X11->display, vi, GLX_RGBA, &res);
 140             format.setRgba(res);
 141             glXGetConfig(X11->display, vi, GLX_RED_SIZE, &res);
 142             format.setRedBufferSize(res);
 143             glXGetConfig(X11->display, vi, GLX_GREEN_SIZE, &res);
 144             format.setGreenBufferSize(res);
 145             glXGetConfig(X11->display, vi, GLX_BLUE_SIZE, &res);
 146             format.setBlueBufferSize(res);
 147             glXGetConfig(X11->display, vi, GLX_ALPHA_SIZE, &res);
 148             format.setAlpha(res);
 149             if (format.alpha())
 150                 format.setAlphaBufferSize(res);
 151             glXGetConfig(X11->display, vi, GLX_ACCUM_RED_SIZE, &res);
 152             format.setAccum(res);
 153             if (format.accum())
 154                 format.setAccumBufferSize(res);
 155             glXGetConfig(X11->display, vi, GLX_STENCIL_SIZE, &res);
 156             format.setStencil(res);
 157             if (format.stencil())
 158                 format.setStencilBufferSize(res);
 159             glXGetConfig(X11->display, vi, GLX_STEREO, &res);
 160             format.setStereo(res);
 161             glXGetConfig(X11->display, vi, GLX_SAMPLE_BUFFERS_ARB, &res);
 162             format.setSampleBuffers(res);
 163             if (format.sampleBuffers()) {
 164                 glXGetConfig(X11->display, vi, GLX_SAMPLES_ARB, &res);
 165                 format.setSamples(res);
 166             }
 167
 168             QGLWindowSurface::surfaceFormat = format;
 169             XFree(vi);
 170
 171             printf("using visual class %x, id %x\n", X11->visual_class, X11->visual_id);
 172         }
 173     }
 174 #elif defined(Q_WS_WIN)
 175     QGLWindowSurface::surfaceFormat.setDoubleBuffer(true);
 176
 177     qt_win_owndc_required = true;
 178 #endif
 179 }
 180
 181 //
 182 // QGLWindowSurface
 183 //
 184 class QGLGlobalShareWidget
 185 {
 186 public:
 187     QGLGlobalShareWidget() : widget(0), initializing(false) {
 188         created = true;
 189     }
 190
 191     QGLWidget *shareWidget() {
 192         if (!initializing && !widget && !cleanedUp) {
 193             initializing = true;
 194             widget = new QGLWidget(QGLFormat(QGL::SingleBuffer | QGL::NoDepthBuffer | QGL::NoStencilBuffer));
 195 #ifdef Q_OS_SYMBIAN
 196             if (!widget->context()->isValid()) {
 197                 delete widget;
 198                 widget = 0;
 199                 initializing = false;
 200                 return 0;
 201             }
 202 #endif
 203             widget->resize(1, 1);
 204
 205             // We don't need this internal widget to appear in QApplication::topLevelWidgets()
 206             if (QWidgetPrivate::allWidgets)
 207                 QWidgetPrivate::allWidgets->remove(widget);
 208             initializing = false;
 209         }
 210         return widget;
 211     }
 212
 213     // destroys the share widget and prevents recreation
 214     void cleanup() {
 215         QGLWidget *w = widget;
 216         cleanedUp = true;
 217         widget = 0;
 218         delete w;
 219     }
 220
 221     // destroys the share widget, but allows it to be recreated later on
 222     void destroy() {
 223         if (cleanedUp)
 224             return;
 225
 226         QGLWidget *w = widget;
 227
 228         // prevent potential recursions
 229         cleanedUp = true;
 230         widget = 0;
 231         delete w;
 232         cleanedUp = false;
 233     }
 234
 235     static bool cleanedUp;
 236     static bool created;
 237
 238 private:
 239     QGLWidget *widget;
 240     bool initializing;
 241 };
 242
 243 bool QGLGlobalShareWidget::cleanedUp = false;
 244 bool QGLGlobalShareWidget::created = false;
 245
 246 static void qt_cleanup_gl_share_widget();
 247 Q_GLOBAL_STATIC_WITH_INITIALIZER(QGLGlobalShareWidget, _qt_gl_share_widget,
 248                                  {
 249                                      qAddPostRoutine(qt_cleanup_gl_share_widget);
 250                                  })
 251
 252 static void qt_cleanup_gl_share_widget()
 253 {
 254     if (QGLGlobalShareWidget::created)
 255         _qt_gl_share_widget()->cleanup();
 256 }
 257
 258 QGLWidget* qt_gl_share_widget()
 259 {
 260     if (QGLGlobalShareWidget::cleanedUp)
 261         return 0;
 262     return _qt_gl_share_widget()->shareWidget();
 263 }
 264
 265 void qt_destroy_gl_share_widget()
 266 {
 267     if (QGLGlobalShareWidget::created)
 268         _qt_gl_share_widget()->destroy();
 269 }
 270
 271 const QGLContext *qt_gl_share_context()
 272 {
 273     QGLWidget *widget = qt_gl_share_widget();
 274     if (widget)
 275         return widget->context();
 276     return 0;
 277 }
 278
 279 struct QGLWindowSurfacePrivate
 280 {
 281     QGLFramebufferObject *fbo;
 282     QGLPixelBuffer *pb;
 283     GLuint tex_id;
 284     GLuint pb_tex_id;
 285
 286     int tried_fbo : 1;
 287     int tried_pb : 1;
 288     int destructive_swap_buffers : 1;
 289     int geometry_updated : 1;
 290     int did_paint : 1;
 291
 292     QGLContext *ctx;
 293
 294     QList<QGLContext **> contexts;
 295
 296     QRegion paintedRegion;
 297     QSize size;
 298
 299     QSize textureSize;
 300
 301     QList<QImage> buffers;
 302     QGLWindowSurfaceGLPaintDevice glDevice;
 303     QGLWindowSurface* q_ptr;
 304
 305     bool swap_region_support;
 306 };
 307
 308 QGLFormat QGLWindowSurface::surfaceFormat;
 309 QGLWindowSurface::SwapMode QGLWindowSurface::swapBehavior = QGLWindowSurface::AutomaticSwap;
 310
 311 void QGLWindowSurfaceGLPaintDevice::endPaint()
 312 {
 313     glFlush();
 314     QGLPaintDevice::endPaint();
 315 }
 316
 317 QSize QGLWindowSurfaceGLPaintDevice::size() const
 318 {
 319     return d->size;
 320 }
 321
 322 QGLContext* QGLWindowSurfaceGLPaintDevice::context() const
 323 {
 324     return d->ctx;
 325 }
 326
 327
 328 int QGLWindowSurfaceGLPaintDevice::metric(PaintDeviceMetric m) const
 329 {
 330     return qt_paint_device_metric(d->q_ptr->window(), m);
 331 }
 332
 333 QPaintEngine *QGLWindowSurfaceGLPaintDevice::paintEngine() const
 334 {
 335     return qt_qgl_paint_engine();
 336 }
 337
 338 QGLWindowSurface::QGLWindowSurface(QWidget *window)
 339     : QWindowSurface(window), d_ptr(new QGLWindowSurfacePrivate)
 340 {
 341 //    Q_ASSERT(window->isTopLevel());
 342     d_ptr->pb = 0;
 343     d_ptr->fbo = 0;
 344     d_ptr->ctx = 0;
 345     d_ptr->tex_id = 0;
 346 #if defined (QT_OPENGL_ES_2)
 347     d_ptr->tried_fbo = true;
 348     d_ptr->tried_pb = true;
 349 #else
 350     d_ptr->tried_fbo = false;
 351     d_ptr->tried_pb = false;
 352 #endif
 353     d_ptr->destructive_swap_buffers = qgetenv("QT_GL_SWAPBUFFER_PRESERVE").isNull();
 354     d_ptr->glDevice.d = d_ptr;
 355     d_ptr->q_ptr = this;
 356     d_ptr->geometry_updated = false;
 357     d_ptr->did_paint = false;
 358     d_ptr->swap_region_support = false;
 359 }
 360
 361 QGLWindowSurface::~QGLWindowSurface()
 362 {
 363     if (d_ptr->ctx)
 364         glDeleteTextures(1, &d_ptr->tex_id);
 365 #ifndef Q_WS_QPA // Don't delete the contexts. Destroying the window does that for us
 366     foreach(QGLContext **ctx, d_ptr->contexts) {
 367         delete *ctx;
 368         *ctx = 0;
 369     }
 370 #endif
 371     delete d_ptr->pb;
 372     delete d_ptr->fbo;
 373     delete d_ptr;
 374
 375     if (QGLGlobalShareWidget::cleanedUp)
 376         return;
 377
 378 #ifdef Q_OS_SYMBIAN
 379     // Destroy the context if necessary.
 380     if (qt_gl_share_widget() && !qt_gl_share_context()->isSharing())
 381         qt_destroy_gl_share_widget();
 382 #endif
 383 }
 384
 385 void QGLWindowSurface::deleted(QObject *object)
 386 {
 387     QWidget *widget = qobject_cast<QWidget *>(object);
 388     if (widget) {
 389         if (widget == window()) {
 390             // Make sure that the fbo is destroyed before destroying its context.
 391             delete d_ptr->fbo;
 392             d_ptr->fbo = 0;
 393         }
 394
 395 #ifndef Q_WS_QPA //no need to specifically delete the QGLContext as it will be deleted by QWidget
 396         QWidgetPrivate *widgetPrivate = widget->d_func();
 397         if (widgetPrivate->extraData()) {
 398             union { QGLContext **ctxPtrPtr; void **voidPtrPtr; };
 399             voidPtrPtr = &widgetPrivate->extraData()->glContext;
 400             int index = d_ptr->contexts.indexOf(ctxPtrPtr);
 401             if (index != -1) {
 402                 delete *ctxPtrPtr;
 403                 *ctxPtrPtr = 0;
 404                 d_ptr->contexts.removeAt(index);
 405             }
 406         }
 407 #endif
 408     }
 409 }
 410
 411 void QGLWindowSurface::hijackWindow(QWidget *widget)
 412 {
 413     QWidgetPrivate *widgetPrivate = widget->d_func();
 414     widgetPrivate->createExtra();
 415     if (widgetPrivate->extraData()->glContext)
 416         return;
 417
 418     QGLContext *ctx = NULL;
 419
 420     // For translucent top-level widgets we need alpha in the format.
 421     if (widget->testAttribute(Qt::WA_TranslucentBackground)) {
 422         QGLFormat modFormat(surfaceFormat);
 423         modFormat.setSampleBuffers(false);
 424         modFormat.setSamples(0);
 425         modFormat.setAlpha(true);
 426         ctx = new QGLContext(modFormat, widget);
 427     } else
 428         ctx = new QGLContext(surfaceFormat, widget);
 429
 430     ctx->create(qt_gl_share_context());
 431 #ifdef Q_OS_SYMBIAN
 432     if (!ctx->isValid()) {
 433         delete ctx;
 434         return;
 435     }
 436 #endif
 437 #ifndef QT_NO_EGL
 438     static bool checkedForNOKSwapRegion = false;
 439     static bool haveNOKSwapRegion = false;
 440
 441     if (!checkedForNOKSwapRegion) {
 442         haveNOKSwapRegion = QEgl::hasExtension("EGL_NOK_swap_region2");
 443         checkedForNOKSwapRegion = true;
 444
 445         if (haveNOKSwapRegion)
 446             qDebug() << "Found EGL_NOK_swap_region2 extension. Using partial updates.";
 447     }
 448
 449     d_ptr->destructive_swap_buffers = true;
 450     if (ctx->d_func()->eglContext->configAttrib(EGL_SURFACE_TYPE)&EGL_SWAP_BEHAVIOR_PRESERVED_BIT) {
 451         EGLint swapBehavior;
 452         if (eglQuerySurface(ctx->d_func()->eglContext->display(), ctx->d_func()->eglSurface
 453                             , EGL_SWAP_BEHAVIOR, &swapBehavior)) {
 454             d_ptr->destructive_swap_buffers = (swapBehavior != EGL_BUFFER_PRESERVED);
 455         }
 456     }
 457
 458     d_ptr->swap_region_support = haveNOKSwapRegion;
 459 #endif
 460
 461     widgetPrivate->extraData()->glContext = ctx;
 462
 463     union { QGLContext **ctxPtrPtr; void **voidPtrPtr; };
 464
 465     connect(widget, SIGNAL(destroyed(QObject*)), this, SLOT(deleted(QObject*)));
 466
 467     voidPtrPtr = &widgetPrivate->extraData()->glContext;
 468     d_ptr->contexts << ctxPtrPtr;
 469
 470 #ifndef Q_OS_SYMBIAN
 471     qDebug() << "hijackWindow() context created for" << widget << d_ptr->contexts.size();
 472 #endif
 473 }
 474
 475 QGLContext *QGLWindowSurface::context() const
 476 {
 477     return d_ptr->ctx;
 478 }
 479
 480 QPaintDevice *QGLWindowSurface::paintDevice()
 481 {
 482     updateGeometry();
 483
 484 #ifdef Q_OS_SYMBIAN
 485     // On symbian we always return glDevice, even if it's invalid
 486     return &d_ptr->glDevice;
 487 #else
 488     if (d_ptr->pb)
 489         return d_ptr->pb;
 490
 491     if (d_ptr->ctx)
 492         return &d_ptr->glDevice;
 493
 494     QGLContext *ctx = reinterpret_cast<QGLContext *>(window()->d_func()->extraData()->glContext);
 495     ctx->makeCurrent();
 496
 497     Q_ASSERT(d_ptr->fbo);
 498     return d_ptr->fbo;
 499 #endif
 500 }
 501
 502 static void drawTexture(const QRectF &rect, GLuint tex_id, const QSize &texSize, const QRectF &src = QRectF());
 503
 504 void QGLWindowSurface::beginPaint(const QRegion &)
 505 {
 506     d_ptr->did_paint = true;
 507     updateGeometry();
 508
 509     int clearFlags = 0;
 510
 511     QGLContext *ctx = reinterpret_cast<QGLContext *>(window()->d_func()->extraData()->glContext);
 512
 513     if (!ctx)
 514         return;
 515
 516     if (ctx->d_func()->workaround_needsFullClearOnEveryFrame)
 517         clearFlags = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
 518     else if (ctx->format().alpha())
 519         clearFlags = GL_COLOR_BUFFER_BIT;
 520
 521     if (clearFlags) {
 522         if (d_ptr->fbo)
 523             d_ptr->fbo->bind();
 524
 525         glClearColor(0.0, 0.0, 0.0, 0.0);
 526         glClear(clearFlags);
 527
 528         if (d_ptr->fbo)
 529             d_ptr->fbo->release();
 530     }
 531 }
 532
 533 void QGLWindowSurface::endPaint(const QRegion &rgn)
 534 {
 535     if (context())
 536         d_ptr->paintedRegion |= rgn;
 537
 538     d_ptr->buffers.clear();
 539 }
 540
 541 static void blitTexture(QGLContext *ctx, GLuint texture, const QSize &viewport, const QSize &texSize, const QRect &targetRect, const QRect &sourceRect)
 542 {
 543     glDisable(GL_DEPTH_TEST);
 544     glDisable(GL_SCISSOR_TEST);
 545     glDisable(GL_BLEND);
 546
 547     glViewport(0, 0, viewport.width(), viewport.height());
 548
 549     QGLShaderProgram *blitProgram =
 550         QGLEngineSharedShaders::shadersForContext(ctx)->blitProgram();
 551     blitProgram->bind();
 552     blitProgram->setUniformValue("imageTexture", 0 /*QT_IMAGE_TEXTURE_UNIT*/);
 553
 554     // The shader manager's blit program does not multiply the
 555     // vertices by the pmv matrix, so we need to do the effect
 556     // of the orthographic projection here ourselves.
 557     QRectF r;
 558     qreal w = viewport.width();
 559     qreal h = viewport.height();
 560     r.setLeft((targetRect.left() / w) * 2.0f - 1.0f);
 561     if (targetRect.right() == (viewport.width() - 1))
 562         r.setRight(1.0f);
 563     else
 564         r.setRight((targetRect.right() / w) * 2.0f - 1.0f);
 565     r.setBottom((targetRect.top() / h) * 2.0f - 1.0f);
 566     if (targetRect.bottom() == (viewport.height() - 1))
 567         r.setTop(1.0f);
 568     else
 569         r.setTop((targetRect.bottom() / w) * 2.0f - 1.0f);
 570
 571     drawTexture(r, texture, texSize, sourceRect);
 572 }
 573
 574
 575 void QGLWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)
 576 {
 577     //### Find out why d_ptr->geometry_updated isn't always false.
 578     // flush() should not be called when d_ptr->geometry_updated is true. It assumes that either
 579     // d_ptr->fbo or d_ptr->pb is allocated and has the correct size.
 580     if (d_ptr->geometry_updated)
 581         return;
 582
 583     // did_paint is set to true in ::beginPaint. ::beginPaint means that we
 584     // at least cleared the background (= painted something). In EGL API it's a
 585     // mistake to call swapBuffers if nothing was painted unless
 586     // EGL_BUFFER_PRESERVED is set. This check protects the flush func from
 587     // being executed if it's for nothing.
 588     if (!d_ptr->destructive_swap_buffers && !d_ptr->did_paint)
 589         return;
 590
 591 #ifdef Q_OS_SYMBIAN
 592     if (window() != widget) {
 593         // For performance reasons we don't support
 594         // flushing native child widgets on Symbian.
 595         // It breaks overlapping native child widget
 596         // rendering in some cases but we prefer performance.
 597         return;
 598     }
 599 #endif
 600
 601
 602     QWidget *parent = widget->internalWinId() ? widget : widget->nativeParentWidget();
 603     Q_ASSERT(parent);
 604
 605 #if !defined(Q_WS_QPA)
 606     if (!geometry().isValid())
 607         return;
 608 #else
 609     if (!size().isValid())
 610         return;
 611 #endif
 612
 613     // Needed to support native child-widgets...
 614     hijackWindow(parent);
 615
 616     QRect br = rgn.boundingRect().translated(offset);
 617     br = br.intersected(window()->rect());
 618     QPoint wOffset = qt_qwidget_data(parent)->wrect.topLeft();
 619     QRect rect = br.translated(-offset - wOffset);
 620
 621     const GLenum target = GL_TEXTURE_2D;
 622     Q_UNUSED(target);
 623
 624     if (QGLWindowSurface::swapBehavior == QGLWindowSurface::KillSwap)
 625         return;
 626
 627     if (context()) {
 628         context()->makeCurrent();
 629
 630         if (context()->format().doubleBuffer()) {
 631 #if !defined(QT_OPENGL_ES_2)
 632             if (d_ptr->destructive_swap_buffers) {
 633                 glBindTexture(target, d_ptr->tex_id);
 634
 635                 QVector<QRect> rects = d_ptr->paintedRegion.rects();
 636                 for (int i = 0; i < rects.size(); ++i) {
 637                     QRect br = rects.at(i);
 638                     if (br.isEmpty())
 639                         continue;
 640
 641                     const uint bottom = window()->height() - (br.y() + br.height());
 642                     glCopyTexSubImage2D(target, 0, br.x(), bottom, br.x(), bottom, br.width(), br.height());
 643                 }
 644
 645                 glBindTexture(target, 0);
 646
 647                 QRegion dirtyRegion = QRegion(window()->rect()) - d_ptr->paintedRegion;
 648
 649                 if (!dirtyRegion.isEmpty()) {
 650                     glMatrixMode(GL_MODELVIEW);
 651                     glLoadIdentity();
 652
 653                     glMatrixMode(GL_PROJECTION);
 654                     glLoadIdentity();
 655 #ifndef QT_OPENGL_ES
 656                     glOrtho(0, window()->width(), window()->height(), 0, -999999, 999999);
 657 #else
 658                     glOrthof(0, window()->width(), window()->height(), 0, -999999, 999999);
 659 #endif
 660                     glViewport(0, 0, window()->width(), window()->height());
 661
 662                     QVector<QRect> rects = dirtyRegion.rects();
 663                     glColor4f(1, 1, 1, 1);
 664                     for (int i = 0; i < rects.size(); ++i) {
 665                         QRect rect = rects.at(i);
 666                         if (rect.isEmpty())
 667                             continue;
 668
 669                         drawTexture(rect, d_ptr->tex_id, window()->size(), rect);
 670                     }
 671                 }
 672             }
 673 #endif
 674             bool doingPartialUpdate = false;
 675             if (d_ptr->swap_region_support) {
 676                 if (QGLWindowSurface::swapBehavior == QGLWindowSurface::AutomaticSwap)
 677                     doingPartialUpdate = br.width() * br.height() < parent->geometry().width() * parent->geometry().height() * 0.2;
 678                 else if (QGLWindowSurface::swapBehavior == QGLWindowSurface::AlwaysPartialSwap)
 679                     doingPartialUpdate = true;
 680             }
 681
 682             QGLContext *ctx = reinterpret_cast<QGLContext *>(parent->d_func()->extraData()->glContext);
 683             if (widget != window()) {
 684                 if (initializeOffscreenTexture(window()->size()))
 685                     qWarning() << "QGLWindowSurface: Flushing to native child widget, may lead to significant performance loss";
 686                 glBindTexture(target, d_ptr->tex_id);
 687
 688                 const uint bottom = window()->height() - (br.y() + br.height());
 689                 glCopyTexSubImage2D(target, 0, br.x(), bottom, br.x(), bottom, br.width(), br.height());
 690
 691                 glBindTexture(target, 0);
 692
 693                 ctx->makeCurrent();
 694                 if (doingPartialUpdate)
 695                     blitTexture(ctx, d_ptr->tex_id, parent->size(), window()->size(), rect, br);
 696                 else
 697                     blitTexture(ctx, d_ptr->tex_id, parent->size(), window()->size(), parent->rect(), parent->rect().translated(offset + wOffset));
 698             }
 699
 700             if (doingPartialUpdate)
 701                 ctx->d_func()->swapRegion(br);
 702             else
 703                 ctx->swapBuffers();
 704
 705             d_ptr->paintedRegion = QRegion();
 706         } else {
 707             glFlush();
 708         }
 709         return;
 710     }
 711
 712     QGLContext *previous_ctx = const_cast<QGLContext *>(QGLContext::currentContext());
 713     QGLContext *ctx = reinterpret_cast<QGLContext *>(parent->d_func()->extraData()->glContext);
 714 #ifdef Q_OS_SYMBIAN
 715     if (!ctx)
 716         return;
 717 #endif
 718
 719     // QPainter::end() should have unbound the fbo, otherwise something is very wrong...
 720     Q_ASSERT(!d_ptr->fbo || !d_ptr->fbo->isBound());
 721
 722     if (ctx != previous_ctx) {
 723         ctx->makeCurrent();
 724     }
 725
 726     QSize size = widget->rect().size();
 727     if (d_ptr->destructive_swap_buffers && ctx->format().doubleBuffer()) {
 728         rect = parent->rect();
 729         br = rect.translated(wOffset + offset);
 730         size = parent->size();
 731     }
 732
 733     glDisable(GL_SCISSOR_TEST);
 734
 735     if (d_ptr->fbo && (QGLExtensions::glExtensions() & QGLExtensions::FramebufferBlit)) {
 736         const int h = d_ptr->fbo->height();
 737
 738         const int sx0 = br.left();
 739         const int sx1 = br.left() + br.width();
 740         const int sy0 = h - (br.top() + br.height());
 741         const int sy1 = h - br.top();
 742
 743         const int tx0 = rect.left();
 744         const int tx1 = rect.left() + rect.width();
 745         const int ty0 = parent->height() - (rect.top() + rect.height());
 746         const int ty1 = parent->height() - rect.top();
 747
 748         if (window() == parent || d_ptr->fbo->format().samples() <= 1) {
 749             if (ctx->d_ptr->current_fbo != 0)
 750                 glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, 0);
 751
 752             glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, d_ptr->fbo->handle());
 753
 754             glBlitFramebufferEXT(sx0, sy0, sx1, sy1,
 755                     tx0, ty0, tx1, ty1,
 756                     GL_COLOR_BUFFER_BIT,
 757                     GL_NEAREST);
 758
 759             glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, 0);
 760         } else {
 761 #ifndef Q_OS_SYMBIAN // We don't have FBO pool on Symbian
 762             // can't do sub-region blits with multisample FBOs
 763             QGLFramebufferObject *temp = qgl_fbo_pool()->acquire(d_ptr->fbo->size(), QGLFramebufferObjectFormat());
 764
 765             glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, temp->handle());
 766             glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, d_ptr->fbo->handle());
 767
 768             glBlitFramebufferEXT(0, 0, d_ptr->fbo->width(), d_ptr->fbo->height(),
 769                     0, 0, d_ptr->fbo->width(), d_ptr->fbo->height(),
 770                     GL_COLOR_BUFFER_BIT,
 771                     GL_NEAREST);
 772
 773             glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, temp->handle());
 774             glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, 0);
 775
 776             glBlitFramebufferEXT(sx0, sy0, sx1, sy1,
 777                     tx0, ty0, tx1, ty1,
 778                     GL_COLOR_BUFFER_BIT,
 779                     GL_NEAREST);
 780
 781             glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, 0);
 782
 783             qgl_fbo_pool()->release(temp);
 784 #endif // Q_OS_SYMBIAN
 785         }
 786
 787         ctx->d_ptr->current_fbo = 0;
 788     }
 789 #if !defined(QT_OPENGL_ES_2)
 790     else {
 791         GLuint texture;
 792     if (d_ptr->fbo) {
 793         texture = d_ptr->fbo->texture();
 794     } else {
 795         d_ptr->pb->makeCurrent();
 796         glBindTexture(target, d_ptr->pb_tex_id);
 797         const uint bottom = window()->height() - (br.y() + br.height());
 798         glCopyTexSubImage2D(target, 0, br.x(), bottom, br.x(), bottom, br.width(), br.height());
 799         texture = d_ptr->pb_tex_id;
 800         glBindTexture(target, 0);
 801     }
 802
 803         glDisable(GL_DEPTH_TEST);
 804
 805         if (d_ptr->fbo) {
 806             d_ptr->fbo->release();
 807         } else {
 808             ctx->makeCurrent();
 809         }
 810
 811         glMatrixMode(GL_MODELVIEW);
 812         glLoadIdentity();
 813
 814         glMatrixMode(GL_PROJECTION);
 815         glLoadIdentity();
 816 #ifndef QT_OPENGL_ES
 817         glOrtho(0, size.width(), size.height(), 0, -999999, 999999);
 818 #else
 819         glOrthof(0, size.width(), size.height(), 0, -999999, 999999);
 820 #endif
 821         glViewport(0, 0, size.width(), size.height());
 822
 823         glColor4f(1, 1, 1, 1);
 824         drawTexture(rect, texture, window()->size(), br);
 825
 826         if (d_ptr->fbo)
 827             d_ptr->fbo->bind();
 828     }
 829 #else
 830     // OpenGL/ES 2.0 version of the fbo blit.
 831     else if (d_ptr->fbo) {
 832         Q_UNUSED(target);
 833
 834         if (d_ptr->fbo->isBound())
 835             d_ptr->fbo->release();
 836
 837         blitTexture(ctx, d_ptr->fbo->texture(), size, window()->size(), rect, br);
 838     }
 839 #endif
 840
 841     if (ctx->format().doubleBuffer())
 842         ctx->swapBuffers();
 843     else
 844         glFlush();
 845
 846     d_ptr->did_paint = false;
 847 }
 848
 849
 850 #if !defined(Q_WS_QPA)
 851 void QGLWindowSurface::setGeometry(const QRect &rect)
 852 {
 853     QWindowSurface::setGeometry(rect);
 854     d_ptr->geometry_updated = true;
 855 }
 856 #else
 857 void QGLWindowSurface::resize(const QSize &size)
 858 {
 859     QWindowSurface::resize(size);
 860     d_ptr->geometry_updated = true;
 861 }
 862 #endif
 863
 864 void QGLWindowSurface::updateGeometry() {
 865     if (!d_ptr->geometry_updated)
 866         return;
 867     d_ptr->geometry_updated = false;
 868
 869     bool hijack(true);
 870     QWidgetPrivate *wd = window()->d_func();
 871     if (wd->extraData() && wd->extraData()->glContext) {
 872 #ifdef Q_OS_SYMBIAN // Symbian needs to recreate the context when native window size changes
 873         if (d_ptr->size != geometry().size()) {
 874             QGLContext *ctx = reinterpret_cast<QGLContext *>(wd->extraData()->glContext);
 875
 876             if (ctx == QGLContext::currentContext())
 877                  ctx->doneCurrent();
 878
 879             ctx->d_func()->destroyEglSurfaceForDevice();
 880
 881             // Delete other contexts (shouldn't happen too often, if at all)
 882             while (d_ptr->contexts.size()) {
 883                 QGLContext **ctxPtrPtr = d_ptr->contexts.takeFirst();
 884                 if ((*ctxPtrPtr) != ctx)
 885                     delete *ctxPtrPtr;
 886             }
 887             union { QGLContext **ctxPtrPtr; void **voidPtrPtr; };
 888             voidPtrPtr = &wd->extraData()->glContext;
 889             d_ptr->contexts << ctxPtrPtr;
 890
 891             ctx->d_func()->eglSurface = ctx->d_func()->eglContext->createSurface(window());
 892
 893             // Swap behaviour has been checked already in previous hijackWindow call.
 894             // Reset swap behaviour based on that flag.
 895             if (d_ptr->destructive_swap_buffers) {
 896                 eglSurfaceAttrib(QEgl::display(), ctx->d_func()->eglSurfaceForDevice(),
 897                                     EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED);
 898
 899                 if (eglGetError() != EGL_SUCCESS)
 900                     qWarning("QGLWindowSurface::updateGeometry() - could not re-enable destroyed swap behaviour");
 901             } else {
 902                 eglSurfaceAttrib(QEgl::display(), ctx->d_func()->eglSurfaceForDevice(),
 903                                     EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED);
 904
 905                 if (eglGetError() != EGL_SUCCESS)
 906                     qWarning("QGLWindowSurface::updateGeometry() - could not re-enable preserved swap behaviour");
 907             }
 908         }
 909 #endif
 910         hijack = false; // we already have gl context for widget
 911     }
 912
 913     if (hijack)
 914         hijackWindow(window());
 915
 916     QGLContext *ctx = reinterpret_cast<QGLContext *>(wd->extraData()->glContext);
 917 #ifdef Q_OS_SYMBIAN
 918     if (!ctx)
 919         return;
 920 #endif
 921 #ifdef Q_WS_MAC
 922     ctx->updatePaintDevice();
 923 #endif
 924
 925     QSize surfSize = geometry().size();
 926
 927     if (surfSize.width() <= 0 || surfSize.height() <= 0)
 928         return;
 929
 930     if (d_ptr->size == surfSize)
 931         return;
 932
 933     d_ptr->size = surfSize;
 934
 935     if (d_ptr->ctx) {
 936 #ifndef QT_OPENGL_ES_2
 937         if (d_ptr->destructive_swap_buffers)
 938             initializeOffscreenTexture(surfSize);
 939 #endif
 940         return;
 941     }
 942
 943     const GLenum target = GL_TEXTURE_2D;
 944     if (d_ptr->destructive_swap_buffers
 945         && (QGLExtensions::glExtensions() & QGLExtensions::FramebufferObject)
 946         && (d_ptr->fbo || !d_ptr->tried_fbo)
 947         && qt_gl_preferGL2Engine())
 948     {
 949         d_ptr->tried_fbo = true;
 950         ctx->d_ptr->internal_context = true;
 951         ctx->makeCurrent();
 952         delete d_ptr->fbo;
 953
 954         QGLFramebufferObjectFormat format;
 955         format.setAttachment(QGLFramebufferObject::CombinedDepthStencil);
 956         format.setInternalTextureFormat(GLenum(GL_RGBA));
 957         format.setTextureTarget(target);
 958
 959         if (QGLExtensions::glExtensions() & QGLExtensions::FramebufferBlit)
 960             format.setSamples(8);
 961
 962         d_ptr->fbo = new QGLFramebufferObject(surfSize, format);
 963
 964         if (d_ptr->fbo->isValid()) {
 965             qDebug() << "Created Window Surface FBO" << surfSize
 966                      << "with samples" << d_ptr->fbo->format().samples();
 967             return;
 968         } else {
 969             qDebug() << "QGLWindowSurface: Failed to create valid FBO, falling back";
 970             delete d_ptr->fbo;
 971             d_ptr->fbo = 0;
 972         }
 973     }
 974
 975 #if !defined(QT_OPENGL_ES_2) && !defined(Q_WS_QPA) //QPA doesn't support pixelbuffers
 976     if (d_ptr->destructive_swap_buffers && (d_ptr->pb || !d_ptr->tried_pb)) {
 977         d_ptr->tried_pb = true;
 978
 979         if (d_ptr->pb) {
 980             d_ptr->pb->makeCurrent();
 981             glDeleteTextures(1, &d_ptr->pb_tex_id);
 982         }
 983
 984         delete d_ptr->pb;
 985
 986         d_ptr->pb = new QGLPixelBuffer(surfSize.width(), surfSize.height(),
 987                                         QGLFormat(QGL::SampleBuffers | QGL::StencilBuffer | QGL::DepthBuffer),
 988                                         qt_gl_share_widget());
 989
 990         if (d_ptr->pb->isValid()) {
 991             qDebug() << "Created Window Surface Pixelbuffer, Sample buffers:" << d_ptr->pb->format().sampleBuffers();
 992             d_ptr->pb->makeCurrent();
 993
 994             glGenTextures(1, &d_ptr->pb_tex_id);
 995             glBindTexture(target, d_ptr->pb_tex_id);
 996             glTexImage2D(target, 0, GL_RGBA, surfSize.width(), surfSize.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 997
 998             glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 999             glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1000             glBindTexture(target, 0);
1001
1002             glMatrixMode(GL_PROJECTION);
1003             glLoadIdentity();
1004             glOrtho(0, d_ptr->pb->width(), d_ptr->pb->height(), 0, -999999, 999999);
1005
1006             d_ptr->pb->d_ptr->qctx->d_func()->internal_context = true;
1007             return;
1008         } else {
1009             qDebug() << "QGLWindowSurface: Failed to create valid pixelbuffer, falling back";
1010             delete d_ptr->pb;
1011             d_ptr->pb = 0;
1012         }
1013     }
1014 #endif // !defined(QT_OPENGL_ES_2) !defined(Q_WS_QPA)
1015
1016     ctx->makeCurrent();
1017
1018 #ifndef QT_OPENGL_ES_2
1019     if (d_ptr->destructive_swap_buffers)
1020         initializeOffscreenTexture(surfSize);
1021 #endif
1022 #ifndef Q_OS_SYMBIAN
1023     qDebug() << "QGLWindowSurface: Using plain widget as window surface" << this;
1024 #endif
1025     d_ptr->ctx = ctx;
1026     d_ptr->ctx->d_ptr->internal_context = true;
1027 }
1028
1029 bool QGLWindowSurface::initializeOffscreenTexture(const QSize &size)
1030 {
1031     if (size == d_ptr->textureSize)
1032         return false;
1033
1034     glGenTextures(1, &d_ptr->tex_id);
1035     glBindTexture(GL_TEXTURE_2D, d_ptr->tex_id);
1036     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, size.width(), size.height(), 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1037
1038     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1039     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1040     glBindTexture(GL_TEXTURE_2D, 0);
1041
1042     d_ptr->textureSize = size;
1043     return true;
1044 }
1045
1046 bool QGLWindowSurface::scroll(const QRegion &area, int dx, int dy)
1047 {
1048     // this code randomly fails currently for unknown reasons
1049     return false;
1050
1051     if (!d_ptr->pb)
1052         return false;
1053
1054     d_ptr->pb->makeCurrent();
1055
1056     QRect br = area.boundingRect();
1057
1058 #if 0
1059     // ## workaround driver issue (scrolling by these deltas is unbearably slow for some reason)
1060     // ## maybe we should use glCopyTexSubImage insteadk
1061     if (dx == 1 || dx == -1 || dy == 1 || dy == -1 || dy == 2)
1062         return false;
1063
1064     glRasterPos2i(br.x() + dx, br.y() + br.height() + dy);
1065     glCopyPixels(br.x(), d_ptr->pb->height() - (br.y() + br.height()), br.width(), br.height(), GL_COLOR);
1066     return true;
1067 #endif
1068
1069     const GLenum target = GL_TEXTURE_2D;
1070
1071     glBindTexture(target, d_ptr->tex_id);
1072     glCopyTexImage2D(target, 0, GL_RGBA, br.x(), d_ptr->pb->height() - (br.y() + br.height()), br.width(), br.height(), 0);
1073     glBindTexture(target, 0);
1074
1075     drawTexture(br.translated(dx, dy), d_ptr->tex_id, window()->size());
1076
1077     return true;
1078 }
1079
1080 static void drawTexture(const QRectF &rect, GLuint tex_id, const QSize &texSize, const QRectF &br)
1081 {
1082     const GLenum target = GL_TEXTURE_2D;
1083     QRectF src = br.isEmpty()
1084         ? QRectF(QPointF(), texSize)
1085         : QRectF(QPointF(br.x(), texSize.height() - br.bottom()), br.size());
1086
1087     if (target == GL_TEXTURE_2D) {
1088         qreal width = texSize.width();
1089         qreal height = texSize.height();
1090
1091         src.setLeft(src.left() / width);
1092         src.setRight(src.right() / width);
1093         src.setTop(src.top() / height);
1094         src.setBottom(src.bottom() / height);
1095     }
1096
1097     const GLfloat tx1 = src.left();
1098     const GLfloat tx2 = src.right();
1099     const GLfloat ty1 = src.top();
1100     const GLfloat ty2 = src.bottom();
1101
1102     GLfloat texCoordArray[4*2] = {
1103         tx1, ty2, tx2, ty2, tx2, ty1, tx1, ty1
1104     };
1105
1106     GLfloat vertexArray[4*2];
1107     extern void qt_add_rect_to_array(const QRectF &r, GLfloat *array); // qpaintengine_opengl.cpp
1108     qt_add_rect_to_array(rect, vertexArray);
1109
1110 #if !defined(QT_OPENGL_ES_2)
1111     glVertexPointer(2, GL_FLOAT, 0, vertexArray);
1112     glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
1113
1114     glBindTexture(target, tex_id);
1115     glEnable(target);
1116
1117     glEnableClientState(GL_VERTEX_ARRAY);
1118     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1119     glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1120     glDisableClientState(GL_VERTEX_ARRAY);
1121     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1122
1123     glDisable(target);
1124     glBindTexture(target, 0);
1125 #else
1126     glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, vertexArray);
1127     glVertexAttribPointer(QT_TEXTURE_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, texCoordArray);
1128
1129     glBindTexture(target, tex_id);
1130
1131     glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
1132     glEnableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
1133     glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1134     glDisableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
1135     glDisableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
1136
1137     glBindTexture(target, 0);
1138 #endif
1139 }
1140
1141 QImage *QGLWindowSurface::buffer(const QWidget *widget)
1142 {
1143     QImage image;
1144
1145     if (d_ptr->pb)
1146         image = d_ptr->pb->toImage();
1147     else if (d_ptr->fbo)
1148         image = d_ptr->fbo->toImage();
1149
1150     if (image.isNull())
1151         return 0;
1152
1153     QRect rect = widget->rect();
1154     rect.translate(widget->mapTo(widget->window(), QPoint()));
1155
1156     QImage subImage = image.copy(rect);
1157     d_ptr->buffers << subImage;
1158     return &d_ptr->buffers.last();
1159 }
1160
1161 QWindowSurface::WindowSurfaceFeatures QGLWindowSurface::features() const
1162 {
1163     WindowSurfaceFeatures features = 0;
1164     if (!d_ptr->destructive_swap_buffers || d_ptr->swap_region_support)
1165         features |= PartialUpdates;
1166     if (!d_ptr->destructive_swap_buffers)
1167         features |= PreservedContents;
1168     return features;
1169 }
1170
1171 QT_END_NAMESPACE
1172