diff options
Diffstat (limited to 'src/opengl/qopenglcompositorbackingstore.cpp')
| -rw-r--r-- | src/opengl/qopenglcompositorbackingstore.cpp | 292 |
1 files changed, 292 insertions, 0 deletions
diff --git a/src/opengl/qopenglcompositorbackingstore.cpp b/src/opengl/qopenglcompositorbackingstore.cpp new file mode 100644 index 0000000000..40400e2a19 --- /dev/null +++ b/src/opengl/qopenglcompositorbackingstore.cpp @@ -0,0 +1,292 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the plugins of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QtGui/QOpenGLContext> +#include <QtGui/QWindow> +#include <QtGui/QPainter> +#include <QtGui/QOffscreenSurface> +#include <qpa/qplatformbackingstore.h> +#include <private/qwindow_p.h> + +#include "qopenglcompositorbackingstore_p.h" +#include "qopenglcompositor_p.h" + +#ifndef GL_UNPACK_ROW_LENGTH +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#endif + +QT_BEGIN_NAMESPACE + +/*! + \class QOpenGLCompositorBackingStore + \brief A backing store implementation for OpenGL + \since 5.4 + \internal + \ingroup qpa + + This implementation uploads raster-rendered widget windows into + textures. It is meant to be used with QOpenGLCompositor that + composites the textures onto a single native window using OpenGL. + This means that multiple top-level widgets are supported without + creating actual native windows for each of them. + + \note It is important to call notifyComposited() from the + corresponding platform window's endCompositing() callback + (inherited from QOpenGLCompositorWindow). + + \note When implementing QOpenGLCompositorWindow::textures() for + windows of type RasterSurface or RasterGLSurface, simply return + the list provided by this class' textures(). +*/ + +QOpenGLCompositorBackingStore::QOpenGLCompositorBackingStore(QWindow *window) + : QPlatformBackingStore(window), + m_window(window), + m_bsTexture(0), + m_bsTextureContext(0), + m_textures(new QPlatformTextureList), + m_lockedWidgetTextures(0) +{ +} + +QOpenGLCompositorBackingStore::~QOpenGLCompositorBackingStore() +{ + if (m_bsTexture) { + QOpenGLContext *ctx = QOpenGLContext::currentContext(); + // With render-to-texture-widgets QWidget makes sure the TLW's shareContext() is + // made current before destroying backingstores. That is however not the case for + // windows with regular widgets only. + QScopedPointer<QOffscreenSurface> tempSurface; + if (!ctx) { + ctx = QOpenGLCompositor::instance()->context(); + tempSurface.reset(new QOffscreenSurface); + tempSurface->setFormat(ctx->format()); + tempSurface->create(); + ctx->makeCurrent(tempSurface.data()); + } + + if (m_bsTextureContext && ctx->shareGroup() == m_bsTextureContext->shareGroup()) + glDeleteTextures(1, &m_bsTexture); + else + qWarning("QOpenGLCompositorBackingStore: Texture is not valid in the current context"); + + if (tempSurface) + ctx->doneCurrent(); + } + + delete m_textures; // this does not actually own any GL resources +} + +QPaintDevice *QOpenGLCompositorBackingStore::paintDevice() +{ + return &m_image; +} + +void QOpenGLCompositorBackingStore::updateTexture() +{ + if (!m_bsTexture) { + m_bsTextureContext = QOpenGLContext::currentContext(); + Q_ASSERT(m_bsTextureContext); + glGenTextures(1, &m_bsTexture); + glBindTexture(GL_TEXTURE_2D, m_bsTexture); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_image.width(), m_image.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); + } else { + glBindTexture(GL_TEXTURE_2D, m_bsTexture); + } + + if (!m_dirty.isNull()) { + QRegion fixed; + QRect imageRect = m_image.rect(); + + QOpenGLContext *ctx = QOpenGLContext::currentContext(); + if (!ctx->isOpenGLES() || ctx->format().majorVersion() >= 3) { + for (const QRect &rect : m_dirty) { + QRect r = imageRect & rect; + glPixelStorei(GL_UNPACK_ROW_LENGTH, m_image.width()); + glTexSubImage2D(GL_TEXTURE_2D, 0, r.x(), r.y(), r.width(), r.height(), GL_RGBA, GL_UNSIGNED_BYTE, + m_image.constScanLine(r.y()) + r.x() * 4); + glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); + } + } else { + for (const QRect &rect : m_dirty) { + // intersect with image rect to be sure + QRect r = imageRect & rect; + + // if the rect is wide enough it's cheaper to just + // extend it instead of doing an image copy + if (r.width() >= imageRect.width() / 2) { + r.setX(0); + r.setWidth(imageRect.width()); + } + + fixed |= r; + } + for (const QRect &rect : fixed) { + // if the sub-rect is full-width we can pass the image data directly to + // OpenGL instead of copying, since there's no gap between scanlines + if (rect.width() == imageRect.width()) { + glTexSubImage2D(GL_TEXTURE_2D, 0, 0, rect.y(), rect.width(), rect.height(), GL_RGBA, GL_UNSIGNED_BYTE, + m_image.constScanLine(rect.y())); + } else { + glTexSubImage2D(GL_TEXTURE_2D, 0, rect.x(), rect.y(), rect.width(), rect.height(), GL_RGBA, GL_UNSIGNED_BYTE, + m_image.copy(rect).constBits()); + } + } + } + + m_dirty = QRegion(); + } +} + +void QOpenGLCompositorBackingStore::flush(QWindow *window, const QRegion ®ion, const QPoint &offset) +{ + // Called for ordinary raster windows. + + Q_UNUSED(region); + Q_UNUSED(offset); + + QOpenGLCompositor *compositor = QOpenGLCompositor::instance(); + QOpenGLContext *dstCtx = compositor->context(); + Q_ASSERT(dstCtx); + + QWindow *dstWin = compositor->targetWindow(); + if (!dstWin) + return; + + dstCtx->makeCurrent(dstWin); + updateTexture(); + m_textures->clear(); + m_textures->appendTexture(nullptr, m_bsTexture, window->geometry()); + + compositor->update(); +} + +void QOpenGLCompositorBackingStore::composeAndFlush(QWindow *window, const QRegion ®ion, const QPoint &offset, + QPlatformTextureList *textures, + bool translucentBackground) +{ + // QOpenGLWidget/QQuickWidget content provided as textures. The raster content goes on top. + + Q_UNUSED(region); + Q_UNUSED(offset); + Q_UNUSED(translucentBackground); + + QOpenGLCompositor *compositor = QOpenGLCompositor::instance(); + QOpenGLContext *dstCtx = compositor->context(); + Q_ASSERT(dstCtx); // setTarget() must have been called before, e.g. from QEGLFSWindow + + // The compositor's context and the context to which QOpenGLWidget/QQuickWidget + // textures belong are not the same. They share resources, though. + Q_ASSERT(qt_window_private(window)->shareContext()->shareGroup() == dstCtx->shareGroup()); + + QWindow *dstWin = compositor->targetWindow(); + if (!dstWin) + return; + + dstCtx->makeCurrent(dstWin); + + QWindowPrivate::get(window)->lastComposeTime.start(); + + m_textures->clear(); + for (int i = 0; i < textures->count(); ++i) + m_textures->appendTexture(textures->source(i), textures->textureId(i), textures->geometry(i), + textures->clipRect(i), textures->flags(i)); + + updateTexture(); + m_textures->appendTexture(nullptr, m_bsTexture, window->geometry()); + + textures->lock(true); + m_lockedWidgetTextures = textures; + + compositor->update(); +} + +void QOpenGLCompositorBackingStore::notifyComposited() +{ + if (m_lockedWidgetTextures) { + QPlatformTextureList *textureList = m_lockedWidgetTextures; + m_lockedWidgetTextures = 0; // may reenter so null before unlocking + textureList->lock(false); + } +} + +void QOpenGLCompositorBackingStore::beginPaint(const QRegion ®ion) +{ + m_dirty |= region; + + if (m_image.hasAlphaChannel()) { + QPainter p(&m_image); + p.setCompositionMode(QPainter::CompositionMode_Source); + for (const QRect &r : region) + p.fillRect(r, Qt::transparent); + } +} + +void QOpenGLCompositorBackingStore::resize(const QSize &size, const QRegion &staticContents) +{ + Q_UNUSED(staticContents); + + QOpenGLCompositor *compositor = QOpenGLCompositor::instance(); + QOpenGLContext *dstCtx = compositor->context(); + QWindow *dstWin = compositor->targetWindow(); + if (!dstWin) + return; + + m_image = QImage(size, QImage::Format_RGBA8888); + + m_window->create(); + + dstCtx->makeCurrent(dstWin); + if (m_bsTexture) { + glDeleteTextures(1, &m_bsTexture); + m_bsTexture = 0; + m_bsTextureContext = nullptr; + } +} + +QImage QOpenGLCompositorBackingStore::toImage() const +{ + return m_image; +} + +QT_END_NAMESPACE |