Differential D24215 Diff 66902 libkwineffects/kwineffectquickview.cpp

Changeset View

Standalone View

View Options

libkwineffects/kwineffectquickview.cpp

  • This file was added.
1​/********************************************************************
2​ KWin - the KDE window manager
3​ This file is part of the KDE project.
4​
5​Copyright (C) 2019 David Edmundson <davidedmundson@kde.org>
6​
7​This program is free software; you can redistribute it and/or modify
8​it under the terms of the GNU General Public License as published by
9​the Free Software Foundation; either version 2 of the License, or
10​(at your option) any later version.
11​
12​This program is distributed in the hope that it will be useful,
13​but WITHOUT ANY WARRANTY; without even the implied warranty of
14​MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15​GNU General Public License for more details.
16​
17​You should have received a copy of the GNU General Public License
18​along with this program. If not, see <http://www.gnu.org/licenses/>.
19​*********************************************************************/
20​
21​#include "kwineffectquickview.h"
22​
23​#include "kwinglutils.h"
24​#include "kwineffects.h"
25​#include "logging_p.h"
26​
27​#include <QQmlEngine>
28​#include <QQuickItem>
29​#include <QQmlContext>
30​#include <QQmlComponent>
31​#include <QQuickView>
32​#include <QQuickRenderControl>
33​#include <QUrl>
34​
35​#include <QOffscreenSurface>
36​#include <QOpenGLContext>
37​#include <QOpenGLFramebufferObject>
38​#include <QTimer>
39​
40​#include <KDeclarative/QmlObjectSharedEngine>
41​
42​using namespace KWin;
43​
44​static std::unique_ptr<QOpenGLContext> s_shareContext;
45​
46​class Q_DECL_HIDDEN EffectQuickView::Private
47​{
48​public:
49​ QQuickWindow *m_view;
50​ QQuickRenderControl *m_renderControl;
51​ QScopedPointer<QOpenGLContext> m_glcontext;
52​ QScopedPointer<QOffscreenSurface> m_offscreenSurface;
53​ QScopedPointer<QOpenGLFramebufferObject> m_fbo;
54​
55​ QImage m_image;
56​ QScopedPointer<GLTexture> m_textureExport;
57​ // if we should capture a QImage after rendering into our BO.
58​ // Used for either software QtQuick rendering and nonGL kwin rendering
59​ bool m_useBlit = false;
60​ bool m_visible = true;
61​
62​ void releaseResources();
63​};
64​
65​class Q_DECL_HIDDEN EffectQuickScene::Private
66​{
67​public:
68​ KDeclarative::QmlObjectSharedEngine *qmlObject = nullptr;
69​};
70​
71​EffectQuickView::EffectQuickView(QObject *parent)
72​ : EffectQuickView(parent, effects->isOpenGLCompositing() ? ExportMode::Texture : ExportMode::Image)
73​{
74​}
75​
76​EffectQuickView::EffectQuickView(QObject *parent, ExportMode exportMode)
77​ : QObject(parent)
78​ , d(new EffectQuickView::Private)
79​{
80​ d->m_renderControl = new QQuickRenderControl(this);
81​
82​ d->m_view = new QQuickWindow(d->m_renderControl);
83​ d->m_view->setFlags(Qt::FramelessWindowHint);
84​ d->m_view->setColor(Qt::transparent);
85​
86​ if (exportMode == ExportMode::Image) {
87​ d->m_useBlit = true;
88​ }
zzagUnsubmitted
Done

Mark as const

zzag: Mark as const
89​
90​ const bool usingGl = d->m_view->rendererInterface()->graphicsApi() == QSGRendererInterface::OpenGL;
91​
zzagUnsubmitted
Done

Use qCDebug.

zzag: Use qCDebug.
92​ if (!usingGl) {
93​ qCDebug(LIBKWINEFFECTS) << "QtQuick Software rendering mode detected";
94​ d->m_useBlit = true;
95​ d->m_renderControl->initialize(nullptr);
96​ } else {
97​ QSurfaceFormat format;
98​ format.setOption(QSurfaceFormat::ResetNotification);
99​ format.setDepthBufferSize(16);
100​ format.setStencilBufferSize(8);
101​
102​ d->m_glcontext.reset(new QOpenGLContext);
103​ d->m_glcontext->setShareContext(s_shareContext.get());
104​ d->m_glcontext->setFormat(format);
105​ d->m_glcontext->create();
106​
107​ // and the offscreen surface
108​ d->m_offscreenSurface.reset(new QOffscreenSurface);
109​ d->m_offscreenSurface->setFormat(d->m_glcontext->format());
110​ d->m_offscreenSurface->create();
111​
112​ d->m_glcontext->makeCurrent(d->m_offscreenSurface.data());
113​ d->m_renderControl->initialize(d->m_glcontext.data());
114​ d->m_glcontext->doneCurrent();
115​
116​ if (!d->m_glcontext->shareContext()) {
117​ qCDebug(LIBKWINEFFECTS) << "Failed to create a shared context, falling back to raster rendering";
118​
zzagUnsubmitted
Done

You don't need to put whitespace after colon.

zzag: You don't need to put whitespace after colon.
119​ qCDebug(LIBKWINEFFECTS) << "Extra debug:";
120​ qCDebug(LIBKWINEFFECTS) << "our context:" << d->m_glcontext.data();
121​ qCDebug(LIBKWINEFFECTS) << "share context:" << s_shareContext.get();
122​
123​ // still render via GL, but blit for presentation
124​ d->m_useBlit = true;
125​ }
126​ }
127​
128​ auto updateSize = [this]() { contentItem()->setSize(d->m_view->size()); };
129​ updateSize();
130​ connect(d->m_view, &QWindow::widthChanged, this, updateSize);
131​ connect(d->m_view, &QWindow::heightChanged, this, updateSize);
132​
133​ QTimer *t = new QTimer(this);
134​ t->setSingleShot(true);
135​ t->setInterval(10);
136​
137​ connect(t, &QTimer::timeout, this, &EffectQuickView::update);
138​ connect(d->m_renderControl, &QQuickRenderControl::renderRequested, t, [t]() { t->start(); });
139​ connect(d->m_renderControl, &QQuickRenderControl::sceneChanged, t, [t]() { t->start(); });
140​}
141​
142​EffectQuickView::~EffectQuickView()
143​{
144​ if (d->m_glcontext) {
145​ d->m_glcontext->makeCurrent(d->m_offscreenSurface.data());
146​ d->m_renderControl->invalidate();
147​ d->m_glcontext->doneCurrent();
148​ }
149​}
150​
151​void EffectQuickView::update()
152​{
153​ if (!d->m_visible) {
154​ return;
155​ }
156​ if (d->m_view->size().isEmpty()) {
157​ return;
158​ }
159​
160​ bool usingGl = d->m_glcontext;
161​
162​ if (usingGl) {
163​ if (!d->m_glcontext->makeCurrent(d->m_offscreenSurface.data())) {
164​ // probably a context loss event, kwin is about to reset all the effects anyway
165​ return;
166​ }
167​
168​ if (d->m_fbo.isNull() || d->m_fbo->size() != d->m_view->size()) {
169​ d->m_textureExport.reset(nullptr);
170​ d->m_fbo.reset(new QOpenGLFramebufferObject(d->m_view->size(), QOpenGLFramebufferObject::CombinedDepthStencil));
171​ if (!d->m_fbo->isValid()) {
172​ d->m_fbo.reset();
173​ d->m_glcontext->doneCurrent();
174​ return;
175​ }
176​ }
177​ d->m_view->setRenderTarget(d->m_fbo.data());
178​ }
179​
180​ d->m_renderControl->polishItems();
181​ d->m_renderControl->sync();
182​
183​ d->m_renderControl->render();
184​ if (usingGl) {
185​ d->m_view->resetOpenGLState();
186​ }
187​
188​ if (d->m_useBlit) {
189​ d->m_image = d->m_renderControl->grab();
190​ }
191​
192​ if (usingGl) {
193​ QOpenGLFramebufferObject::bindDefault();
194​ d->m_glcontext->doneCurrent();
195​ }
196​ emit repaintNeeded();
197​}
zzagUnsubmitted
Done

Use static_cast

zzag: Use static_cast
198​
199​void EffectQuickView::forwardMouseEvent(QEvent *e)
200​{
201​ if (!d->m_visible) {
202​ return;
203​ }
204​ QMouseEvent *me = static_cast<QMouseEvent *>(e);
205​ const QPoint widgetPos = d->m_view->mapFromGlobal(me->pos());
206​
207​ QMouseEvent cloneEvent(me->type(), widgetPos, me->pos(), me->button(), me->buttons(), me->modifiers());
208​ QCoreApplication::sendEvent(d->m_view, &cloneEvent);
209​ e->setAccepted(cloneEvent.isAccepted());
210​}
211​
212​void EffectQuickView::forwardKeyEvent(QKeyEvent *keyEvent)
213​{
214​ if (!d->m_visible) {
215​ return;
216​ }
217​ QCoreApplication::sendEvent(d->m_view, keyEvent);
218​}
219​
220​void EffectQuickView::setShareContext(std::unique_ptr<QOpenGLContext> context)
221​{
222​ s_shareContext = std::move(context);
223​}
224​
225​QRect EffectQuickView::geometry() const
226​{
227​ return d->m_view->geometry();
228​}
229​
230​QQuickItem *EffectQuickView::contentItem() const
231​{
232​ return d->m_view->contentItem();
233​}
234​
235​void EffectQuickView::setVisible(bool visible)
236​{
237​ if (d->m_visible == visible) {
238​ return;
239​ }
240​ d->m_visible = visible;
241​
242​ if (visible){
243​ d->m_renderControl->renderRequested();
244​ } else {
245​ // deferred to not change GL context
246​ QTimer::singleShot(0, this, [this]() {
247​ d->releaseResources();
248​ });
249​ }
250​}
251​
252​bool EffectQuickView::isVisible() const
253​{
254​ return d->m_visible;
255​}
256​
257​void EffectQuickView::show()
258​{
259​ setVisible(true);
260​}
261​
262​void EffectQuickView::hide()
263​{
264​ setVisible(false);
265​}
266​
267​GLTexture *EffectQuickView::bufferAsTexture()
268​{
269​ if (d->m_useBlit) {
270​ if (d->m_image.isNull()) {
271​ return nullptr;
272​ }
273​ d->m_textureExport.reset(new GLTexture(d->m_image));
274​ } else {
275​ if (!d->m_fbo) {
276​ return nullptr;
277​ }
278​ if (!d->m_textureExport) {
279​ d->m_textureExport.reset(new GLTexture(d->m_fbo->texture(), d->m_fbo->format().internalTextureFormat(), d->m_fbo->size()));
280​ }
281​ }
282​ return d->m_textureExport.data();
283​}
284​
285​QImage EffectQuickView::bufferAsImage() const
286​{
287​ return d->m_image;
288​}
289​
290​QSize EffectQuickView::size() const
291​{
292​ return d->m_view->geometry().size();
293​}
294​
295​void EffectQuickView::setGeometry(const QRect &rect)
296​{
297​ const QRect oldGeometry = d->m_view->geometry();
298​ d->m_view->setGeometry(rect);
299​ emit geometryChanged(oldGeometry, rect);
300​}
301​
302​void EffectQuickView::Private::releaseResources()
303​{
304​ if (m_glcontext) {
305​ m_glcontext->makeCurrent(m_offscreenSurface.data());
306​ m_view->releaseResources();
307​ m_glcontext->doneCurrent();
308​ } else {
309​ m_view->releaseResources();
310​ }
311​}
312​
313​EffectQuickScene::EffectQuickScene(QObject *parent)
314​ : EffectQuickView(parent)
315​ , d(new EffectQuickScene::Private)
316​{
317​}
318​
319​EffectQuickScene::EffectQuickScene(QObject *parent, EffectQuickView::ExportMode exportMode)
320​ : EffectQuickView(parent, exportMode)
321​ , d(new EffectQuickScene::Private)
322​{
323​}
324​
325​EffectQuickScene::~EffectQuickScene()
326​{
327​}
328​
329​void EffectQuickScene::setSource(const QUrl &source)
330​{
331​ if (!d->qmlObject) {
332​ d->qmlObject = new KDeclarative::QmlObjectSharedEngine(this);
333​ }
334​ d->qmlObject->setSource(source);
335​
336​ QQuickItem *item = rootItem();
337​ if (!item) {
338​ qCDebug(LIBKWINEFFECTS) << "Could not load effect quick view" << source;
339​ return;
340​ }
341​ item->setParentItem(contentItem());
342​
343​ auto updateSize = [item, this]() { item->setSize(contentItem()->size()); };
344​ updateSize();
345​ connect(contentItem(), &QQuickItem::widthChanged, item, updateSize);
346​ connect(contentItem(), &QQuickItem::heightChanged, item, updateSize);
347​}
348​
349​QQmlContext *EffectQuickScene::rootContext() const
350​{
351​ return d->qmlObject->rootContext();
352​}
353​
354​QQuickItem *EffectQuickScene::rootItem() const
355​{
356​ return qobject_cast<QQuickItem *>(d->qmlObject->rootObject());
357​}