source: trunk/src/opengl/qwindowsurface_gl.cpp@ 687

Last change on this file since 687 was 651, checked in by Dmitry A. Kuminov, 16 years ago

trunk: Merged in qt 4.6.2 sources.
File size: 27.5 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2010 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** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
15**
16** GNU Lesser General Public License Usage
17** Alternatively, this file may be used under the terms of the GNU Lesser
18** General Public License version 2.1 as published by the Free Software
19** Foundation and appearing in the file LICENSE.LGPL included in the
20** packaging of this file. Please review the following information to
21** ensure the GNU Lesser General Public License version 2.1 requirements
22** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23**
24** In addition, as a special exception, Nokia gives you certain additional
25** rights. These rights are described in the Nokia Qt LGPL Exception
26** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you have questions regarding the use of this file, please contact
37** Nokia at qt-info@nokia.com.
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#ifdef QT_OPENGL_ES_1_CL
86#include "qgl_cl_p.h"
87#endif
88
89#ifdef QT_OPENGL_ES
90#include <private/qegl_p.h>
91#endif
92
93QT_BEGIN_NAMESPACE
94
95//
96// QGLGraphicsSystem
97//
98#ifdef Q_WS_WIN
99extern Q_GUI_EXPORT bool qt_win_owndc_required;
100#endif
101QGLGraphicsSystem::QGLGraphicsSystem()
102 : QGraphicsSystem()
103{
104#if defined(Q_WS_X11) && !defined(QT_OPENGL_ES)
105 // only override the system defaults if the user hasn't already
106 // picked a visual
107 if (X11->visual == 0 && X11->visual_id == -1 && X11->visual_class == -1) {
108 // find a double buffered, RGBA visual that supports OpenGL
109 // and set that as the default visual for windows in Qt
110 int i = 0;
111 int spec[16];
112 spec[i++] = GLX_RGBA;
113 spec[i++] = GLX_DOUBLEBUFFER;
114
115 if (!qgetenv("QT_GL_SWAPBUFFER_PRESERVE").isNull()) {
116 spec[i++] = GLX_DEPTH_SIZE;
117 spec[i++] = 8;
118 spec[i++] = GLX_STENCIL_SIZE;
119 spec[i++] = 8;
120 spec[i++] = GLX_SAMPLE_BUFFERS_ARB;
121 spec[i++] = 1;
122 spec[i++] = GLX_SAMPLES_ARB;
123 spec[i++] = 4;
124 }
125
126 spec[i++] = XNone;
127
128 XVisualInfo *vi = glXChooseVisual(X11->display, X11->defaultScreen, spec);
129 if (vi) {
130 X11->visual_id = vi->visualid;
131 X11->visual_class = vi->c_class;
132
133 QGLFormat format;
134 int res;
135 glXGetConfig(X11->display, vi, GLX_LEVEL, &res);
136 format.setPlane(res);
137 glXGetConfig(X11->display, vi, GLX_DOUBLEBUFFER, &res);
138 format.setDoubleBuffer(res);
139 glXGetConfig(X11->display, vi, GLX_DEPTH_SIZE, &res);
140 format.setDepth(res);
141 if (format.depth())
142 format.setDepthBufferSize(res);
143 glXGetConfig(X11->display, vi, GLX_RGBA, &res);
144 format.setRgba(res);
145 glXGetConfig(X11->display, vi, GLX_RED_SIZE, &res);
146 format.setRedBufferSize(res);
147 glXGetConfig(X11->display, vi, GLX_GREEN_SIZE, &res);
148 format.setGreenBufferSize(res);
149 glXGetConfig(X11->display, vi, GLX_BLUE_SIZE, &res);
150 format.setBlueBufferSize(res);
151 glXGetConfig(X11->display, vi, GLX_ALPHA_SIZE, &res);
152 format.setAlpha(res);
153 if (format.alpha())
154 format.setAlphaBufferSize(res);
155 glXGetConfig(X11->display, vi, GLX_ACCUM_RED_SIZE, &res);
156 format.setAccum(res);
157 if (format.accum())
158 format.setAccumBufferSize(res);
159 glXGetConfig(X11->display, vi, GLX_STENCIL_SIZE, &res);
160 format.setStencil(res);
161 if (format.stencil())
162 format.setStencilBufferSize(res);
163 glXGetConfig(X11->display, vi, GLX_STEREO, &res);
164 format.setStereo(res);
165 glXGetConfig(X11->display, vi, GLX_SAMPLE_BUFFERS_ARB, &res);
166 format.setSampleBuffers(res);
167 if (format.sampleBuffers()) {
168 glXGetConfig(X11->display, vi, GLX_SAMPLES_ARB, &res);
169 format.setSamples(res);
170 }
171
172 QGLWindowSurface::surfaceFormat = format;
173 XFree(vi);
174
175 printf("using visual class %x, id %x\n", X11->visual_class, X11->visual_id);
176 }
177 }
178#elif defined(Q_WS_WIN)
179 QGLWindowSurface::surfaceFormat.setDoubleBuffer(true);
180
181 qt_win_owndc_required = true;
182#endif
183}
184
185//
186// QGLWindowSurface
187//
188
189class QGLGlobalShareWidget
190{
191public:
192 QGLGlobalShareWidget() : widget(0), initializing(false) {}
193
194 QGLWidget *shareWidget() {
195 if (!initializing && !widget && !cleanedUp) {
196 initializing = true;
197 widget = new QGLWidget;
198 // We dont need this internal widget to appear in QApplication::topLevelWidgets()
199 if (QWidgetPrivate::allWidgets)
200 QWidgetPrivate::allWidgets->remove(widget);
201 initializing = false;
202 }
203 return widget;
204 }
205
206 void cleanup() {
207 QGLWidget *w = widget;
208 cleanedUp = true;
209 widget = 0;
210 delete w;
211 }
212
213 static bool cleanedUp;
214
215private:
216 QGLWidget *widget;
217 bool initializing;
218};
219
220bool QGLGlobalShareWidget::cleanedUp = false;
221
222static void qt_cleanup_gl_share_widget();
223Q_GLOBAL_STATIC_WITH_INITIALIZER(QGLGlobalShareWidget, _qt_gl_share_widget,
224 {
225 qAddPostRoutine(qt_cleanup_gl_share_widget);
226 })
227
228static void qt_cleanup_gl_share_widget()
229{
230 _qt_gl_share_widget()->cleanup();
231}
232
233QGLWidget* qt_gl_share_widget()
234{
235 if (QGLGlobalShareWidget::cleanedUp)
236 return 0;
237 return _qt_gl_share_widget()->shareWidget();
238}
239
240
241struct QGLWindowSurfacePrivate
242{
243 QGLFramebufferObject *fbo;
244 QGLPixelBuffer *pb;
245 GLuint tex_id;
246 GLuint pb_tex_id;
247
248 int tried_fbo : 1;
249 int tried_pb : 1;
250 int destructive_swap_buffers : 1;
251 int geometry_updated : 1;
252
253 QGLContext *ctx;
254
255 QList<QGLContext **> contexts;
256
257 QRegion paintedRegion;
258 QSize size;
259
260 QList<QImage> buffers;
261 QGLWindowSurfaceGLPaintDevice glDevice;
262 QGLWindowSurface* q_ptr;
263};
264
265QGLFormat QGLWindowSurface::surfaceFormat;
266
267void QGLWindowSurfaceGLPaintDevice::endPaint()
268{
269 glFlush();
270 QGLPaintDevice::endPaint();
271}
272
273QSize QGLWindowSurfaceGLPaintDevice::size() const
274{
275 return d->size;
276}
277
278QGLContext* QGLWindowSurfaceGLPaintDevice::context() const
279{
280 return d->ctx;
281}
282
283
284int QGLWindowSurfaceGLPaintDevice::metric(PaintDeviceMetric m) const
285{
286 return qt_paint_device_metric(d->q_ptr->window(), m);
287}
288
289QPaintEngine *QGLWindowSurfaceGLPaintDevice::paintEngine() const
290{
291 return qt_qgl_paint_engine();
292}
293
294QGLWindowSurface::QGLWindowSurface(QWidget *window)
295 : QWindowSurface(window), d_ptr(new QGLWindowSurfacePrivate)
296{
297 Q_ASSERT(window->isTopLevel());
298 d_ptr->pb = 0;
299 d_ptr->fbo = 0;
300 d_ptr->ctx = 0;
301#if defined (QT_OPENGL_ES_2)
302 d_ptr->tried_fbo = true;
303 d_ptr->tried_pb = true;
304#else
305 d_ptr->tried_fbo = false;
306 d_ptr->tried_pb = false;
307#endif
308 d_ptr->destructive_swap_buffers = qgetenv("QT_GL_SWAPBUFFER_PRESERVE").isNull();
309 d_ptr->glDevice.d = d_ptr;
310 d_ptr->q_ptr = this;
311 d_ptr->geometry_updated = false;
312}
313
314QGLWindowSurface::~QGLWindowSurface()
315{
316 if (d_ptr->ctx)
317 glDeleteTextures(1, &d_ptr->tex_id);
318 foreach(QGLContext **ctx, d_ptr->contexts) {
319 delete *ctx;
320 *ctx = 0;
321 }
322
323 delete d_ptr->pb;
324 delete d_ptr->fbo;
325 delete d_ptr;
326}
327
328void QGLWindowSurface::deleted(QObject *object)
329{
330 // Make sure that the fbo is destroyed before destroying its context.
331 delete d_ptr->fbo;
332 d_ptr->fbo = 0;
333
334 QWidget *widget = qobject_cast<QWidget *>(object);
335 if (widget) {
336 QWidgetPrivate *widgetPrivate = widget->d_func();
337 if (widgetPrivate->extraData()) {
338 union { QGLContext **ctxPtr; void **voidPtr; };
339 voidPtr = &widgetPrivate->extraData()->glContext;
340 int index = d_ptr->contexts.indexOf(ctxPtr);
341 if (index != -1) {
342 delete *ctxPtr;
343 *ctxPtr = 0;
344 d_ptr->contexts.removeAt(index);
345 }
346 }
347 }
348}
349
350void QGLWindowSurface::hijackWindow(QWidget *widget)
351{
352 QWidgetPrivate *widgetPrivate = widget->d_func();
353 widgetPrivate->createExtra();
354 if (widgetPrivate->extraData()->glContext)
355 return;
356
357 QGLContext *ctx = new QGLContext(surfaceFormat, widget);
358 ctx->create(qt_gl_share_widget()->context());
359
360#if defined(Q_WS_X11) && defined(QT_OPENGL_ES)
361 // Create the EGL surface to draw into. QGLContext::chooseContext()
362 // does not do this for X11/EGL, but does do it for other platforms.
363 // This probably belongs in qgl_x11egl.cpp.
364 QGLContextPrivate *ctxpriv = ctx->d_func();
365 ctxpriv->eglSurface = ctxpriv->eglContext->createSurface(widget);
366 if (ctxpriv->eglSurface == EGL_NO_SURFACE) {
367 qWarning() << "hijackWindow() could not create EGL surface";
368 }
369 qDebug("QGLWindowSurface - using EGLConfig %d", reinterpret_cast<int>(ctxpriv->eglContext->config()));
370#endif
371
372 widgetPrivate->extraData()->glContext = ctx;
373
374 union { QGLContext **ctxPtr; void **voidPtr; };
375
376 connect(widget, SIGNAL(destroyed(QObject*)), this, SLOT(deleted(QObject*)));
377
378 voidPtr = &widgetPrivate->extraData()->glContext;
379 d_ptr->contexts << ctxPtr;
380 qDebug() << "hijackWindow() context created for" << widget << d_ptr->contexts.size();
381}
382
383QGLContext *QGLWindowSurface::context() const
384{
385 return d_ptr->ctx;
386}
387
388QPaintDevice *QGLWindowSurface::paintDevice()
389{
390 updateGeometry();
391
392 if (d_ptr->pb)
393 return d_ptr->pb;
394
395 if (d_ptr->ctx)
396 return &d_ptr->glDevice;
397
398 QGLContext *ctx = reinterpret_cast<QGLContext *>(window()->d_func()->extraData()->glContext);
399 ctx->makeCurrent();
400 return d_ptr->fbo;
401}
402
403static void drawTexture(const QRectF &rect, GLuint tex_id, const QSize &texSize, const QRectF &src = QRectF());
404
405void QGLWindowSurface::beginPaint(const QRegion &)
406{
407}
408
409void QGLWindowSurface::endPaint(const QRegion &rgn)
410{
411 if (context())
412 d_ptr->paintedRegion |= rgn;
413
414 d_ptr->buffers.clear();
415}
416
417void QGLWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)
418{
419 if (context() && widget != window()) {
420 qWarning("No native child widget support in GL window surface without FBOs or pixel buffers");
421 return;
422 }
423
424 //### Find out why d_ptr->geometry_updated isn't always false.
425 // flush() should not be called when d_ptr->geometry_updated is true. It assumes that either
426 // d_ptr->fbo or d_ptr->pb is allocated and has the correct size.
427 if (d_ptr->geometry_updated)
428 return;
429
430 QWidget *parent = widget->internalWinId() ? widget : widget->nativeParentWidget();
431 Q_ASSERT(parent);
432
433 if (!geometry().isValid())
434 return;
435
436 // Needed to support native child-widgets...
437 hijackWindow(parent);
438
439 QRect br = rgn.boundingRect().translated(offset);
440 br = br.intersected(window()->rect());
441 QPoint wOffset = qt_qwidget_data(parent)->wrect.topLeft();
442 QRect rect = br.translated(-offset - wOffset);
443
444 const GLenum target = GL_TEXTURE_2D;
445 Q_UNUSED(target);
446
447 if (context()) {
448 context()->makeCurrent();
449
450 if (context()->format().doubleBuffer()) {
451#if !defined(QT_OPENGL_ES_2)
452 if (d_ptr->destructive_swap_buffers) {
453 glBindTexture(target, d_ptr->tex_id);
454
455 QVector<QRect> rects = d_ptr->paintedRegion.rects();
456 for (int i = 0; i < rects.size(); ++i) {
457 QRect br = rects.at(i);
458 if (br.isEmpty())
459 continue;
460
461 const uint bottom = window()->height() - (br.y() + br.height());
462 glCopyTexSubImage2D(target, 0, br.x(), bottom, br.x(), bottom, br.width(), br.height());
463 }
464
465 glBindTexture(target, 0);
466
467 QRegion dirtyRegion = QRegion(window()->rect()) - d_ptr->paintedRegion;
468
469 if (!dirtyRegion.isEmpty()) {
470 glMatrixMode(GL_MODELVIEW);
471 glLoadIdentity();
472
473 glMatrixMode(GL_PROJECTION);
474 glLoadIdentity();
475#ifndef QT_OPENGL_ES
476 glOrtho(0, window()->width(), window()->height(), 0, -999999, 999999);
477#else
478 glOrthof(0, window()->width(), window()->height(), 0, -999999, 999999);
479#endif
480 glViewport(0, 0, window()->width(), window()->height());
481
482 QVector<QRect> rects = dirtyRegion.rects();
483 glColor4f(1, 1, 1, 1);
484 for (int i = 0; i < rects.size(); ++i) {
485 QRect rect = rects.at(i);
486 if (rect.isEmpty())
487 continue;
488
489 drawTexture(rect, d_ptr->tex_id, window()->size(), rect);
490 }
491 }
492 }
493#endif
494 d_ptr->paintedRegion = QRegion();
495 context()->swapBuffers();
496 } else {
497 glFlush();
498 }
499
500 return;
501 }
502
503 QGLContext *previous_ctx = const_cast<QGLContext *>(QGLContext::currentContext());
504 QGLContext *ctx = reinterpret_cast<QGLContext *>(parent->d_func()->extraData()->glContext);
505
506 // QPainter::end() should have unbound the fbo, otherwise something is very wrong...
507 Q_ASSERT(!d_ptr->fbo || !d_ptr->fbo->isBound());
508
509 if (ctx != previous_ctx) {
510 ctx->makeCurrent();
511 }
512
513 QSize size = widget->rect().size();
514 if (d_ptr->destructive_swap_buffers && ctx->format().doubleBuffer()) {
515 rect = parent->rect();
516 br = rect.translated(wOffset + offset);
517 size = parent->size();
518 }
519
520 glDisable(GL_SCISSOR_TEST);
521
522 if (d_ptr->fbo && (QGLExtensions::glExtensions() & QGLExtensions::FramebufferBlit)) {
523 const int h = d_ptr->fbo->height();
524
525 const int sx0 = br.left();
526 const int sx1 = br.left() + br.width();
527 const int sy0 = h - (br.top() + br.height());
528 const int sy1 = h - br.top();
529
530 const int tx0 = rect.left();
531 const int tx1 = rect.left() + rect.width();
532 const int ty0 = parent->height() - (rect.top() + rect.height());
533 const int ty1 = parent->height() - rect.top();
534
535 if (window() == parent || d_ptr->fbo->format().samples() <= 1) {
536 // glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, 0);
537 glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, d_ptr->fbo->handle());
538
539 glBlitFramebufferEXT(sx0, sy0, sx1, sy1,
540 tx0, ty0, tx1, ty1,
541 GL_COLOR_BUFFER_BIT,
542 GL_NEAREST);
543
544 glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, 0);
545 } else {
546 // can't do sub-region blits with multisample FBOs
547 QGLFramebufferObject *temp = qgl_fbo_pool()->acquire(d_ptr->fbo->size(), QGLFramebufferObjectFormat());
548
549 glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, temp->handle());
550 glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, d_ptr->fbo->handle());
551
552 glBlitFramebufferEXT(0, 0, d_ptr->fbo->width(), d_ptr->fbo->height(),
553 0, 0, d_ptr->fbo->width(), d_ptr->fbo->height(),
554 GL_COLOR_BUFFER_BIT,
555 GL_NEAREST);
556
557 glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, temp->handle());
558 glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, 0);
559
560 glBlitFramebufferEXT(sx0, sy0, sx1, sy1,
561 tx0, ty0, tx1, ty1,
562 GL_COLOR_BUFFER_BIT,
563 GL_NEAREST);
564
565 glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, 0);
566
567 qgl_fbo_pool()->release(temp);
568 }
569 }
570#if !defined(QT_OPENGL_ES_2)
571 else {
572 GLuint texture;
573 if (d_ptr->fbo) {
574 texture = d_ptr->fbo->texture();
575 } else {
576 d_ptr->pb->makeCurrent();
577 glBindTexture(target, d_ptr->pb_tex_id);
578 const uint bottom = window()->height() - (br.y() + br.height());
579 glCopyTexSubImage2D(target, 0, br.x(), bottom, br.x(), bottom, br.width(), br.height());
580 texture = d_ptr->pb_tex_id;
581 glBindTexture(target, 0);
582 }
583
584 glDisable(GL_DEPTH_TEST);
585
586 if (d_ptr->fbo) {
587 d_ptr->fbo->release();
588 } else {
589 ctx->makeCurrent();
590 }
591
592 glMatrixMode(GL_MODELVIEW);
593 glLoadIdentity();
594
595 glMatrixMode(GL_PROJECTION);
596 glLoadIdentity();
597#ifndef QT_OPENGL_ES
598 glOrtho(0, size.width(), size.height(), 0, -999999, 999999);
599#else
600 glOrthof(0, size.width(), size.height(), 0, -999999, 999999);
601#endif
602 glViewport(0, 0, size.width(), size.height());
603
604 glColor4f(1, 1, 1, 1);
605 drawTexture(rect, texture, window()->size(), br);
606
607 if (d_ptr->fbo)
608 d_ptr->fbo->bind();
609 }
610#else
611 // OpenGL/ES 2.0 version of the fbo blit.
612 else if (d_ptr->fbo) {
613 Q_UNUSED(target);
614
615 GLuint texture = d_ptr->fbo->texture();
616
617 glDisable(GL_DEPTH_TEST);
618
619 if (d_ptr->fbo->isBound())
620 d_ptr->fbo->release();
621
622 glViewport(0, 0, size.width(), size.height());
623
624 QGLShaderProgram *blitProgram =
625 QGLEngineSharedShaders::shadersForContext(ctx)->blitProgram();
626 blitProgram->bind();
627 blitProgram->setUniformValue("imageTexture", 0 /*QT_IMAGE_TEXTURE_UNIT*/);
628
629 // The shader manager's blit program does not multiply the
630 // vertices by the pmv matrix, so we need to do the effect
631 // of the orthographic projection here ourselves.
632 QRectF r;
633 qreal w = size.width() ? size.width() : 1.0f;
634 qreal h = size.height() ? size.height() : 1.0f;
635 r.setLeft((rect.left() / w) * 2.0f - 1.0f);
636 if (rect.right() == (size.width() - 1))
637 r.setRight(1.0f);
638 else
639 r.setRight((rect.right() / w) * 2.0f - 1.0f);
640 r.setBottom((rect.top() / h) * 2.0f - 1.0f);
641 if (rect.bottom() == (size.height() - 1))
642 r.setTop(1.0f);
643 else
644 r.setTop((rect.bottom() / w) * 2.0f - 1.0f);
645
646 drawTexture(r, texture, window()->size(), br);
647 }
648#endif
649
650 if (ctx->format().doubleBuffer())
651 ctx->swapBuffers();
652 else
653 glFlush();
654}
655
656
657void QGLWindowSurface::setGeometry(const QRect &rect)
658{
659 QWindowSurface::setGeometry(rect);
660 d_ptr->geometry_updated = true;
661}
662
663
664void QGLWindowSurface::updateGeometry() {
665 if (!d_ptr->geometry_updated)
666 return;
667 d_ptr->geometry_updated = false;
668
669
670 QRect rect = geometry();
671 hijackWindow(window());
672 QGLContext *ctx = reinterpret_cast<QGLContext *>(window()->d_func()->extraData()->glContext);
673
674#ifdef Q_WS_MAC
675 ctx->updatePaintDevice();
676#endif
677
678 const GLenum target = GL_TEXTURE_2D;
679
680 if (rect.width() <= 0 || rect.height() <= 0)
681 return;
682
683 if (d_ptr->size == rect.size())
684 return;
685
686 d_ptr->size = rect.size();
687
688 if (d_ptr->ctx) {
689#ifndef QT_OPENGL_ES_2
690 if (d_ptr->destructive_swap_buffers) {
691 glBindTexture(target, d_ptr->tex_id);
692 glTexImage2D(target, 0, GL_RGBA, rect.width(), rect.height(), 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
693 glBindTexture(target, 0);
694 }
695#endif
696 return;
697 }
698
699 if (d_ptr->destructive_swap_buffers
700 && (QGLExtensions::glExtensions() & QGLExtensions::FramebufferObject)
701 && (d_ptr->fbo || !d_ptr->tried_fbo)
702 && qt_gl_preferGL2Engine())
703 {
704 d_ptr->tried_fbo = true;
705 ctx->d_ptr->internal_context = true;
706 ctx->makeCurrent();
707 delete d_ptr->fbo;
708
709 QGLFramebufferObjectFormat format;
710 format.setAttachment(QGLFramebufferObject::CombinedDepthStencil);
711 format.setInternalTextureFormat(GLenum(GL_RGBA));
712 format.setTextureTarget(target);
713
714 if (QGLExtensions::glExtensions() & QGLExtensions::FramebufferBlit)
715 format.setSamples(8);
716
717 d_ptr->fbo = new QGLFramebufferObject(rect.size(), format);
718
719 if (d_ptr->fbo->isValid()) {
720 qDebug() << "Created Window Surface FBO" << rect.size()
721 << "with samples" << d_ptr->fbo->format().samples();
722 return;
723 } else {
724 qDebug() << "QGLWindowSurface: Failed to create valid FBO, falling back";
725 delete d_ptr->fbo;
726 d_ptr->fbo = 0;
727 }
728 }
729
730#if !defined(QT_OPENGL_ES_2)
731 if (d_ptr->destructive_swap_buffers && (d_ptr->pb || !d_ptr->tried_pb)) {
732 d_ptr->tried_pb = true;
733
734 if (d_ptr->pb) {
735 d_ptr->pb->makeCurrent();
736 glDeleteTextures(1, &d_ptr->pb_tex_id);
737 }
738
739 delete d_ptr->pb;
740
741 d_ptr->pb = new QGLPixelBuffer(rect.width(), rect.height(),
742 QGLFormat(QGL::SampleBuffers | QGL::StencilBuffer | QGL::DepthBuffer),
743 qt_gl_share_widget());
744
745 if (d_ptr->pb->isValid()) {
746 qDebug() << "Created Window Surface Pixelbuffer, Sample buffers:" << d_ptr->pb->format().sampleBuffers();
747 d_ptr->pb->makeCurrent();
748
749 glGenTextures(1, &d_ptr->pb_tex_id);
750 glBindTexture(target, d_ptr->pb_tex_id);
751 glTexImage2D(target, 0, GL_RGBA, rect.width(), rect.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
752
753 glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
754 glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
755 glBindTexture(target, 0);
756
757 glMatrixMode(GL_PROJECTION);
758 glLoadIdentity();
759 glOrtho(0, d_ptr->pb->width(), d_ptr->pb->height(), 0, -999999, 999999);
760
761 d_ptr->pb->d_ptr->qctx->d_func()->internal_context = true;
762 return;
763 } else {
764 qDebug() << "QGLWindowSurface: Failed to create valid pixelbuffer, falling back";
765 delete d_ptr->pb;
766 d_ptr->pb = 0;
767 }
768 }
769#endif // !defined(QT_OPENGL_ES_2)
770
771 ctx->makeCurrent();
772
773#ifndef QT_OPENGL_ES_2
774 if (d_ptr->destructive_swap_buffers) {
775 glGenTextures(1, &d_ptr->tex_id);
776 glBindTexture(target, d_ptr->tex_id);
777 glTexImage2D(target, 0, GL_RGBA, rect.width(), rect.height(), 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
778
779 glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
780 glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
781 glBindTexture(target, 0);
782 }
783#endif
784
785 qDebug() << "QGLWindowSurface: Using plain widget as window surface" << this;;
786 d_ptr->ctx = ctx;
787 d_ptr->ctx->d_ptr->internal_context = true;
788}
789
790bool QGLWindowSurface::scroll(const QRegion &area, int dx, int dy)
791{
792 // this code randomly fails currently for unknown reasons
793 return false;
794
795 if (!d_ptr->pb)
796 return false;
797
798 d_ptr->pb->makeCurrent();
799
800 QRect br = area.boundingRect();
801
802#if 0
803 // ## workaround driver issue (scrolling by these deltas is unbearably slow for some reason)
804 // ## maybe we should use glCopyTexSubImage insteadk
805 if (dx == 1 || dx == -1 || dy == 1 || dy == -1 || dy == 2)
806 return false;
807
808 glRasterPos2i(br.x() + dx, br.y() + br.height() + dy);
809 glCopyPixels(br.x(), d_ptr->pb->height() - (br.y() + br.height()), br.width(), br.height(), GL_COLOR);
810 return true;
811#endif
812
813 const GLenum target = GL_TEXTURE_2D;
814
815 glBindTexture(target, d_ptr->tex_id);
816 glCopyTexImage2D(target, 0, GL_RGBA, br.x(), d_ptr->pb->height() - (br.y() + br.height()), br.width(), br.height(), 0);
817 glBindTexture(target, 0);
818
819 drawTexture(br.translated(dx, dy), d_ptr->tex_id, window()->size());
820
821 return true;
822}
823
824static void drawTexture(const QRectF &rect, GLuint tex_id, const QSize &texSize, const QRectF &br)
825{
826 const GLenum target = GL_TEXTURE_2D;
827 QRectF src = br.isEmpty()
828 ? QRectF(QPointF(), texSize)
829 : QRectF(QPointF(br.x(), texSize.height() - br.bottom()), br.size());
830
831 if (target == GL_TEXTURE_2D) {
832 qreal width = texSize.width();
833 qreal height = texSize.height();
834
835 src.setLeft(src.left() / width);
836 src.setRight(src.right() / width);
837 src.setTop(src.top() / height);
838 src.setBottom(src.bottom() / height);
839 }
840
841 const q_vertexType tx1 = f2vt(src.left());
842 const q_vertexType tx2 = f2vt(src.right());
843 const q_vertexType ty1 = f2vt(src.top());
844 const q_vertexType ty2 = f2vt(src.bottom());
845
846 q_vertexType texCoordArray[4*2] = {
847 tx1, ty2, tx2, ty2, tx2, ty1, tx1, ty1
848 };
849
850 q_vertexType vertexArray[4*2];
851 extern void qt_add_rect_to_array(const QRectF &r, q_vertexType *array); // qpaintengine_opengl.cpp
852 qt_add_rect_to_array(rect, vertexArray);
853
854#if !defined(QT_OPENGL_ES_2)
855 glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
856 glTexCoordPointer(2, q_vertexTypeEnum, 0, texCoordArray);
857
858 glBindTexture(target, tex_id);
859 glEnable(target);
860
861 glEnableClientState(GL_VERTEX_ARRAY);
862 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
863 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
864 glDisableClientState(GL_VERTEX_ARRAY);
865 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
866
867 glDisable(target);
868 glBindTexture(target, 0);
869#else
870 glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, vertexArray);
871 glVertexAttribPointer(QT_TEXTURE_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, texCoordArray);
872
873 glBindTexture(target, tex_id);
874
875 glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
876 glEnableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
877 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
878 glDisableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
879 glDisableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
880
881 glBindTexture(target, 0);
882#endif
883}
884
885QImage *QGLWindowSurface::buffer(const QWidget *widget)
886{
887 QImage image;
888
889 if (d_ptr->pb)
890 image = d_ptr->pb->toImage();
891 else if (d_ptr->fbo)
892 image = d_ptr->fbo->toImage();
893
894 if (image.isNull())
895 return 0;
896
897 QRect rect = widget->rect();
898 rect.translate(widget->mapTo(widget->window(), QPoint()));
899
900 QImage subImage = image.copy(rect);
901 d_ptr->buffers << subImage;
902 return &d_ptr->buffers.last();
903}
904
905
906
907QT_END_NAMESPACE
908
Note: See TracBrowser for help on using the repository browser.