diff options
Diffstat (limited to 'src/opengl/qwindowsurface_gl.cpp')
| -rw-r--r-- | src/opengl/qwindowsurface_gl.cpp | 661 |
1 files changed, 661 insertions, 0 deletions
diff --git a/src/opengl/qwindowsurface_gl.cpp b/src/opengl/qwindowsurface_gl.cpp new file mode 100644 index 0000000..3dd3064 --- /dev/null +++ b/src/opengl/qwindowsurface_gl.cpp @@ -0,0 +1,661 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the QtOpenGL module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, 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.0, 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. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $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 "qdebug.h" + +#ifdef Q_WS_X11 +#include <private/qt_x11_p.h> +#include <qx11info_x11.h> +#include <private/qwidget_p.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/qpaintengine_opengl_p.h> + +#ifndef GLX_ARB_multisample +#define GLX_SAMPLE_BUFFERS_ARB 100000 +#define GLX_SAMPLES_ARB 100001 +#endif + +QT_BEGIN_NAMESPACE + +// +// QGLGraphicsSystem +// +#ifdef Q_WS_WIN +Q_GUI_EXPORT bool qt_win_owndc_required; +#endif +QGLGraphicsSystem::QGLGraphicsSystem() + : QGraphicsSystem() +{ +#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; +#if 0 + spec[i++] = GLX_DOUBLEBUFFER; + 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; +#endif + 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(false); + + qt_win_owndc_required = true; +#endif +} + +// +// QGLWindowSurface +// + +class QGLGlobalShareWidget +{ +public: + QGLGlobalShareWidget() : widget(0) {} + + QGLWidget *shareWidget() { + if (!widget && !cleanedUp) { + widget = new QGLWidget; + } + return widget; + } + + void cleanup() { + delete widget; + widget = 0; + cleanedUp = true; + } + + static bool cleanedUp; + +private: + QGLWidget *widget; +}; + +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(); +} + +struct QGLWindowSurfacePrivate +{ + QGLFramebufferObject *fbo; + QGLPixelBuffer *pb; + GLuint tex_id; + GLuint pb_tex_id; + + int tried_fbo : 1; + int tried_pb : 1; + + QGLContext *ctx; + + QList<QGLContext **> contexts; + + QRegion paintedRegion; + QSize size; + + QList<QImage> buffers; +}; + +QGLFormat QGLWindowSurface::surfaceFormat; + +QGLWindowSurface::QGLWindowSurface(QWidget *window) + : QWindowSurface(window), d_ptr(new QGLWindowSurfacePrivate) +{ + Q_ASSERT(window->isTopLevel()); + QGLExtensions::init(); + d_ptr->pb = 0; + d_ptr->fbo = 0; + d_ptr->ctx = 0; + d_ptr->tried_fbo = false; + d_ptr->tried_pb = false; +} + +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; +} + +void QGLWindowSurface::hijackWindow(QWidget *widget) +{ + QWidgetPrivate *widgetPrivate = widget->d_func(); + widgetPrivate->createExtra(); + if (widgetPrivate->extraData()->glContext) + return; + + QGLContext *ctx = new QGLContext(surfaceFormat, widget); + ctx->create(qt_gl_share_widget()->context()); +#ifdef Q_WS_MAC + ctx->updatePaintDevice(); +#endif + widgetPrivate->extraData()->glContext = ctx; + + union { QGLContext **ctxPtr; void **voidPtr; }; + + voidPtr = &widgetPrivate->extraData()->glContext; + d_ptr->contexts << ctxPtr; + qDebug() << "hijackWindow() context created for" << widget << d_ptr->contexts.size(); +} + +#if !defined(QT_OPENGL_ES_2) +Q_GLOBAL_STATIC(QOpenGLPaintEngine, qt_gl_window_surface_paintengine) +#endif + +/*! \reimp */ +QPaintEngine *QGLWindowSurface::paintEngine() const +{ +#if !defined(QT_OPENGL_ES_2) + return qt_gl_window_surface_paintengine(); +#else + return 0; +#endif +} + +int QGLWindowSurface::metric(PaintDeviceMetric m) const +{ + return window()->metric(m); +} + +QGLContext *QGLWindowSurface::context() const +{ + return d_ptr->ctx; +} + +QPaintDevice *QGLWindowSurface::paintDevice() +{ + if (d_ptr->pb) + return d_ptr->pb; + + if (d_ptr->ctx) + return this; + + QGLContext *ctx = reinterpret_cast<QGLContext *>(window()->d_func()->extraData()->glContext); + ctx->makeCurrent(); + 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 &) +{ +} + +void QGLWindowSurface::endPaint(const QRegion &rgn) +{ + if (context()) + d_ptr->paintedRegion |= rgn; + + d_ptr->buffers.clear(); +} + +void QGLWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset) +{ + QWidget *parent = widget->internalWinId() ? widget : widget->nativeParentWidget(); + Q_ASSERT(parent); + + 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 = qt_gl_preferredTextureTarget(); + + if (context()) { + context()->makeCurrent(); + + if (context()->format().doubleBuffer()) { + 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()) { + context()->makeCurrent(); + + 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); + } + } + d_ptr->paintedRegion = QRegion(); + + context()->swapBuffers(); + } else { + glFlush(); + } + + return; + } + + QGLContext *ctx = reinterpret_cast<QGLContext *>(parent->d_func()->extraData()->glContext); + 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); + } + + QSize size = widget->rect().size(); + if (ctx->format().doubleBuffer()) { + rect = parent->rect(); + br = rect.translated(wOffset); + size = parent->size(); + } + + ctx->makeCurrent(); +#ifdef Q_WS_MAC + ctx->updatePaintDevice(); +#endif + if (d_ptr->fbo) + d_ptr->fbo->release(); + + 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 (ctx->format().doubleBuffer()) + ctx->swapBuffers(); + else + glFlush(); + + if (d_ptr->fbo) + d_ptr->fbo->bind(); +} + +void QGLWindowSurface::setGeometry(const QRect &rect) +{ + QWindowSurface::setGeometry(rect); + + const GLenum target = qt_gl_preferredTextureTarget(); + + if (rect.width() <= 0 || rect.height() <= 0) + return; + + if (d_ptr->size == rect.size()) + return; + + d_ptr->size = rect.size(); + + if (d_ptr->ctx) { + glBindTexture(target, d_ptr->tex_id); + glTexImage2D(target, 0, GL_RGBA, rect.width(), rect.height(), 0, GL_RGB, GL_UNSIGNED_BYTE, 0); + glBindTexture(target, 0); + return; + } + + if (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(rect.width(), rect.height(), + QGLFormat(QGL::SampleBuffers | QGL::StencilBuffer | QGL::DepthBuffer), + qt_gl_share_widget()); + + if (d_ptr->pb->isValid()) { + qDebug() << "PB 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, rect.width(), rect.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(); +#ifndef QT_OPENGL_ES + glOrtho(0, d_ptr->pb->width(), d_ptr->pb->height(), 0, -999999, 999999); +#else + glOrthof(0, d_ptr->pb->width(), d_ptr->pb->height(), 0, -999999, 999999); +#endif + + 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; + } + } + + if ((QGLExtensions::glExtensions & QGLExtensions::FramebufferObject) && (d_ptr->fbo || !d_ptr->tried_fbo)) { + d_ptr->tried_fbo = true; + hijackWindow(window()); + QGLContext *ctx = reinterpret_cast<QGLContext *>(window()->d_func()->extraData()->glContext); + ctx->d_ptr->internal_context = true; + ctx->makeCurrent(); + delete d_ptr->fbo; + d_ptr->fbo = new QGLFramebufferObject(rect.size(), QGLFramebufferObject::CombinedDepthStencil, + GLenum(target), GLenum(GL_RGBA)); + + d_ptr->fbo->bind(); + if (d_ptr->fbo->isValid()) { + return; + } else { + qDebug() << "QGLWindowSurface: Failed to create valid FBO, falling back"; + delete d_ptr->fbo; + d_ptr->fbo = 0; + } + } + + hijackWindow(window()); + QGLContext *ctx = reinterpret_cast<QGLContext *>(window()->d_func()->extraData()->glContext); + ctx->makeCurrent(); + + glGenTextures(1, &d_ptr->tex_id); + glBindTexture(target, d_ptr->tex_id); + glTexImage2D(target, 0, GL_RGBA, rect.width(), rect.height(), 0, GL_RGB, GL_UNSIGNED_BYTE, 0); + + glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glBindTexture(target, 0); + + qDebug() << "QGLWindowSurface: Using plain widget as window surface" << this;; + d_ptr->ctx = ctx; + d_ptr->ctx->d_ptr->internal_context = 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 = qt_gl_preferredTextureTarget(); + + 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 = qt_gl_preferredTextureTarget(); + 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 q_vertexType tx1 = f2vt(src.left()); + const q_vertexType tx2 = f2vt(src.right()); + const q_vertexType ty1 = f2vt(src.top()); + const q_vertexType ty2 = f2vt(src.bottom()); + + q_vertexType texCoordArray[4*2] = { + tx1, ty2, tx2, ty2, tx2, ty1, tx1, ty1 + }; + + q_vertexType vertexArray[4*2]; + extern void qt_add_rect_to_array(const QRectF &r, q_vertexType *array); // qpaintengine_opengl.cpp + qt_add_rect_to_array(rect, vertexArray); + + glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray); + glTexCoordPointer(2, q_vertexTypeEnum, 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); +} + +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 + |