Differential D5249 Diff 12989 effects/projector/projector.cpp

Changeset View

Standalone View

View Options

effects/projector/projector.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) 2007 Rivo Laks <rivolaks@hot.ee>
6​Copyright (C) 2008 Lucas Murray <lmurray@undefinedfire.com>
7​Copyright (C) 2017 Krzysztof Nowicki <krissn@op.pl>
8​
9​This program is free software; you can redistribute it and/or modify
10​it under the terms of the GNU General Public License as published by
11​the Free Software Foundation; either version 2 of the License, or
12​(at your option) any later version.
13​
14​This program is distributed in the hope that it will be useful,
15​but WITHOUT ANY WARRANTY; without even the implied warranty of
16​MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17​GNU General Public License for more details.
18​
19​You should have received a copy of the GNU General Public License
20​along with this program. If not, see <http://www.gnu.org/licenses/>.
21​*********************************************************************/
22​
23​#include "projector.h"
24​
25​#include <QAction>
26​#include <QFile>
27​#include <kwinglutils.h>
28​#include <kwinglplatform.h>
29​#include <KGlobalAccel>
30​#include <KLocalizedString>
31​#include <QStandardPaths>
32​#include <kwinglutils.h>
33​#include <kwinxrenderutils.h>
34​#include <xcb/render.h>
35​#include <xcb/xfixes.h>
36​
37​#include "projectoreffectadaptor.h"
38​
39​namespace KWin
40​{
41​
42​static Q_CONSTEXPR double maxDeformFactor = 0.4;
43​
44​static const QList<double> cornersMinValues = {
45​ 0.0, 0.0,
46​ 1.0 - maxDeformFactor, 0.0,
47​ 1.0 - maxDeformFactor, 1.0 - maxDeformFactor,
48​ 0.0, 1.0 - maxDeformFactor
49​};
50​
51​static const QList<double> cornersMaxValues = {
52​ maxDeformFactor, maxDeformFactor,
53​ 1.0, maxDeformFactor,
54​ 1.0, 1.0,
55​ maxDeformFactor, 1.0
56​};
57​
58​static const QList<double> cornersDefaulValues = {
59​ 0.0, 0.0,
60​ 1.0, 0.0,
61​ 1.0, 1.0,
62​ 0.0, 1.0
63​};
64​
65​ProjectorEffect::ProjectorEffect()
66​ : m_cursorVisible(false)
67​{
68​ (void) new ProjectorEffectAdaptor(this);
69​
70​ QDBusConnection dbus = QDBusConnection::sessionBus();
71​ dbus.registerObject(QStringLiteral("/Effects/Projector"), this);
72​
73​ connect(effects, &EffectsHandler::screenGeometryChanged, this, &ProjectorEffect::slotScreenGeometryChanged);
74​ connect(effects, &EffectsHandler::mouseChanged, this, &ProjectorEffect::slotMouseChanged);
75​ connect(effects, &EffectsHandler::cursorShapeChanged, this, &ProjectorEffect::recreateTexture);
76​ recreateTexture();
77​}
78​
79​ProjectorEffect::~ProjectorEffect()
80​{
81​ if (m_cursorVisible) {
82​ xcb_xfixes_show_cursor(xcbConnection(), x11RootWindow());
83​ }
84​}
85​
86​bool ProjectorEffect::supported()
87​{
88​ return effects->compositingType() == OpenGL2Compositing;
89​}
90​
91​void ProjectorEffect::prePaintScreen(ScreenPrePaintData &data, int time)
92​{
93​ data.mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS;
94​ effects->prePaintScreen(data, time);
95​}
96​
97​void ProjectorEffect::paintScreen(int mask, QRegion region, ScreenPaintData& data)
98​{
99​ effects->paintScreen(mask, region, data);
100​
101​ if (m_cursorTexture && m_cursorVisible) {
102​ QPoint p = effects->cursorPos();
103​ for (const ScreenData &screenData : m_screenData) {
104​ if ((screenData.number != -1) && (screenData.rect.contains(p))) {
105​ p = translatePoint(p.x() - screenData.rect.left(), p.y() - screenData.rect.top(),
106​ screenData.transMatrix).toPoint();
107​ p.rx() += screenData.rect.left();
108​ p.ry() += screenData.rect.top();
109​ }
110​ }
111​ p -= m_cursorHotSpot;
112​ QRect rect(p.x() + data.xTranslation(), p.y() + data.yTranslation(), m_cursorSize.width(),
113​ m_cursorSize.height());
114​
115​ m_cursorTexture->bind();
116​ glEnable(GL_BLEND);
117​ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
118​ auto s = ShaderManager::instance()->pushShader(ShaderTrait::MapTexture);
119​ QMatrix4x4 mvp = data.projectionMatrix();
120​ mvp.translate(rect.x(), rect.y());
121​ s->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
122​ m_cursorTexture->render(region, rect);
123​ ShaderManager::instance()->popShader();
124​ m_cursorTexture->unbind();
125​ glDisable(GL_BLEND);
126​ }
graesslinUnsubmitted
Not Done

This is something which we should not do. That has major impact on the performance of the overall system. Cursors are on an own layer and thus cursor movement does not require a repaint.

Also on X11 we are not able to perfectly track the cursor. On Wayland, though we have full control over it.

graesslin: This is something which we should not do. That has major impact on the performance of the…
nowickiAuthorUnsubmitted
Not Done

The reason for taking over cursor drawing is that when transformation is applied the pointer pixmap doesn't match the point where the cursor actually hits the windows below it. Since there is no way to apply translation to the HW cursor position drawing a SW cursor is the only way to make the mouse usable with tranformation applied.

nowicki: The reason for taking over cursor drawing is that when transformation is applied the pointer…
nalvarezUnsubmitted
Not Done

I think it would be acceptable if the cursor is drawn just like it is now, on its own layer, even if drawing it without the transformation would make it slightly deformed visually.

You just have to ensure mouse events are properly inverse-transformed so that they go to the right place in the window. Isn't this already done for some effects? Isn't it possible to scale a window and keep interacting with it?

nalvarez: I think it would be acceptable if the cursor is drawn just like it is now, on its own layer…
graesslinUnsubmitted
Not Done

You just have to ensure mouse events are properly inverse-transformed so that they go to the right place in the window. Isn't this already done for some effects?

no that is not done anywhere as X doesn't support it.

graesslin: > You just have to ensure mouse events are properly inverse-transformed so that they go to the…
127​}
128​
129​void ProjectorEffect::prePaintWindow(EffectWindow *w, WindowPrePaintData &data, int time)
130​{
131​ for (const ScreenData &screenData : m_screenData) {
132​ if (screenData.number != -1) {
133​ QRect screenRect = screenData.rect;
134​ screenRect.adjust(0, 0, 1, 1);
135​
136​ if (screenRect.intersects(w->expandedGeometry())) {
137​ data.quads = data.quads.makeGrid(100);
138​ data.quads = data.quads.splitAtX(screenRect.left() - w->x());
139​ data.quads = data.quads.splitAtX(screenRect.right() - w->x());
140​ data.quads = data.quads.splitAtY(screenRect.top() - w->y());
141​ data.quads = data.quads.splitAtY(screenRect.bottom() - w->y());
142​ data.setTransformed();
143​ }
144​ }
145​ }
146​ effects->prePaintWindow(w, data, time);
147​}
148​
149​void ProjectorEffect::drawWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)
150​{
151​ for (const ScreenData &screenData : m_screenData) {
152​ if (screenData.number != -1) {
153​ QRect screenRect = screenData.rect;
154​ screenRect.adjust(0, 0, 1, 1);
155​ WindowQuadList newQuads;
156​ Q_FOREACH (WindowQuad quad, data.quads) {
157​ if (quad.left() + w->x() >= screenRect.left() && quad.top() + w->y() >= screenRect.top() &&
158​ quad.right() + w->x() <= screenRect.right() && quad.bottom() + w->y() <= screenRect.bottom()) {
159​ for (int i = 0; i < 4; i++) {
160​ const QPointF point = translatePoint(quad[i].x() + w->x() - screenRect.left(),
161​ quad[i].y() + w->y() - screenRect.top(),
162​ screenData.transMatrix);
163​ quad[i].setX(point.x() - w->x() + screenRect.left());
164​ quad[i].setY(point.y() - w->y() + screenRect.top());
165​ }
166​ }
167​ newQuads.append(quad);
168​ }
169​ data.quads = newQuads;
170​ }
171​ }
172​ effects->drawWindow(w, mask, region, data);
173​}
174​
175​QPointF ProjectorEffect::translatePoint(float x, float y, const QMatrix3x3 &mat) const
176​{
177​ QGenericMatrix<1, 3, float> pointHomo;
178​ pointHomo(0, 0) = x;
179​ pointHomo(1, 0) = y;
180​ pointHomo(2, 0) = 1.0;
181​ QGenericMatrix<1, 3, float> pointTrans = mat * pointHomo;
182​ return QPoint(pointTrans(0, 0) / pointTrans(2, 0), pointTrans(1, 0) / pointTrans(2, 0));
183​}
184​
185​QMatrix3x3 ProjectorEffect::calculateTransform(const QPolygonF &quad, const QRect &screenRect)
186​{
187​ /* Algorithm based on implementation found in keystone.5c, which is part of xrandr release. */
188​#ifndef NDEBUG
189​ if (quad.length() != 4)
190​ qFatal("Transform quad must have four edges!");
191​#endif
192​ QMatrix3x3 result;
193​ /* The quad stored in configuration is stored in relative form, where each coordinate is a
194​ * value between 0 and 1 inclusive. */
195​ QPolygonF q = quad;
196​ for (QPointF &point : q) {
197​ point.rx() *= screenRect.width();
198​ point.ry() *= screenRect.height();
199​ }
200​ result(0, 2) = q[0].x();
201​ result(1, 2) = q[0].y();
202​ result(2, 2) = 1.0;
203​
204​ const float a = ((q[2].x() - q[3].x()) * (q[1].y() - q[2].y())
205​ - (q[2].y() - q[3].y()) * (q[1].x() - q[2].x())) * screenRect.height();
206​ const float b = (q[2].x() - q[1].x() - q[3].x() + q[0].x()) * (q[1].y() - q[2].y())
207​ - (q[2].y() - q[1].y() - q[3].y() + q[0].y()) * (q[1].x() - q[2].x());
208​
209​ result(2, 1) = -b / a;
210​
211​ result(2, 0) = (q[1].x() != q[2].x()) ?
212​ (result(2, 1) * (q[2].x() - q[3].x()) * screenRect.height()
213​ + q[2].x() - q[1].x() - q[3].x() + q[0].x())
214​ / ((q[1].x() - q[2].x()) * screenRect.width()) :
215​ (result(2, 1) * (q[2].y() - q[3].y()) * screenRect.height()
216​ + q[2].y() - q[1].y() - q[3].y() + q[0].y())
217​ / ((q[1].y() - q[2].y()) * screenRect.width());
218​
219​ result(0, 0) = result(2, 0) * q[1].x() + (q[1].x() - q[0].x()) / screenRect.width();
220​ result(1, 0) = result(2, 0) * q[1].y() + (q[1].y() - q[0].y()) / screenRect.width();
221​
222​ result(0, 1) = result(2, 1) * q[3].x() + (q[3].x() - q[0].x()) / screenRect.height();
223​ result(1, 1) = result(2, 1) * q[3].y() + (q[3].y() - q[0].y()) / screenRect.height();
224​
225​ return result;
226​}
227​
228​bool ProjectorEffect::isActive() const
229​{
230​ return !m_transformedRegion.isEmpty();
231​}
232​
233​void ProjectorEffect::slotScreenGeometryChanged(const QSize &size)
234​{
235​ QVector<QString> screens;
236​
237​ Q_UNUSED(size);
238​
239​ for (int i = 0; i < effects->numScreens(); i++) {
240​ screens.append(effects->screenName(i));
241​ }
242​
243​ QRegion transformedRegion;
244​ for (ScreenData &screenData : m_screenData) {
245​ screenData.number = screens.indexOf(screenData.id);
246​ if (screenData.number >= 0) {
247​ screenData.rect = effects->clientArea(ScreenArea, screenData.number, effects->currentDesktop());
248​ transformedRegion += screenData.rect;
249​ screenData.transMatrix = calculateTransform(screenData.quad, screenData.rect);
250​ } else {
251​ }
252​ }
253​ m_transformedRegion = transformedRegion;
254​
255​ effects->addRepaintFull();
256​}
257​
258​void ProjectorEffect::recreateTexture()
259​{
260​ effects->makeOpenGLContextCurrent();
261​ // load the cursor-theme image from the Xcursor-library
262​ xcb_xfixes_get_cursor_image_cookie_t keks = xcb_xfixes_get_cursor_image_unchecked(xcbConnection());
263​ xcb_xfixes_get_cursor_image_reply_t *ximg = xcb_xfixes_get_cursor_image_reply(xcbConnection(), keks, 0);
graesslinUnsubmitted
Not Done

unrelated to the fact that I think we shouldn't do cursor manipulation: we do have access to the cursor image in the effects API.

graesslin: unrelated to the fact that I think we shouldn't do cursor manipulation: we do have access to…
264​ if (ximg) {
265​ // turn the XcursorImage into a QImage that will be used to create the GLTexture/XRenderPicture.
266​ m_cursorSize = QSize(ximg->width, ximg->height);
267​ m_cursorHotSpot = QPoint(ximg->xhot, ximg->yhot);
268​ uint32_t *bits = xcb_xfixes_get_cursor_image_cursor_image(ximg);
269​ QImage img((uchar*)bits, m_cursorSize.width(), m_cursorSize.height(),
270​ QImage::Format_ARGB32_Premultiplied);
271​ m_cursorTexture.reset(new GLTexture(img));
272​ m_cursorTexture->setFilter(GL_LINEAR);
273​ free(ximg);
274​ }
275​ else {
276​ m_cursorTexture.reset();
277​ }
278​}
279​
280​void ProjectorEffect::slotMouseChanged(const QPoint& pos, const QPoint& old,
281​ Qt::MouseButtons buttons, Qt::MouseButtons oldbuttons,
282​ Qt::KeyboardModifiers modifiers,
283​ Qt::KeyboardModifiers oldmodifiers)
284​{
285​ Q_UNUSED(buttons)
286​ Q_UNUSED(oldbuttons)
287​ Q_UNUSED(modifiers)
288​ Q_UNUSED(oldmodifiers)
289​
290​ m_cursorPos = pos;
291​ const QPoint p = pos - m_cursorHotSpot;
292​ const QRect rect(p.x(), p.y(), m_cursorSize.width(), m_cursorSize.height());
293​ const bool cursorVisible = m_transformedRegion.contains(rect);
294​ if ((m_cursorVisible && (pos != old)) || (cursorVisible != m_cursorVisible)) {
295​ effects->addRepaintFull();
296​ }
297​ if (cursorVisible != m_cursorVisible) {
298​ (cursorVisible ? xcb_xfixes_hide_cursor : xcb_xfixes_show_cursor)(xcbConnection(), x11RootWindow());
299​ }
300​ m_cursorVisible = cursorVisible;
301​}
302​
303​bool ProjectorEffect::setScreenTranslation(const QString &screen, const QList<double> &corners)
304​{
305​ if (corners.length() != 8) {
306​ qCWarning(KWINEFFECTS) << "Expected array of 8 corner coordinates, found" << corners.length() << "items";
307​ return false;
308​ }
309​
310​ auto screenDataIt = m_screenData.begin();
311​ for (; screenDataIt != m_screenData.end() && screenDataIt->id != screen; screenDataIt++) {};
312​
313​ if (corners == cornersDefaulValues) {
314​ if (screenDataIt != m_screenData.end()) {
315​ m_screenData.erase(screenDataIt);
316​ }
317​ } else {
318​ auto minIt = cornersMinValues.begin();
319​ auto maxIt = cornersMaxValues.begin();
320​ for (const float &val : corners) {
321​ if (val < *minIt || val > *maxIt) {
322​ qCWarning(KWINEFFECTS) << "Allowed values for corner coordinate "
323​ << minIt - cornersMinValues.begin() << " are between " << *minIt << " and "
324​ << *maxIt << " inclusive";
325​ return false;
326​ }
327​ minIt++;
328​ maxIt++;
329​ }
330​
331​ if (screenDataIt == m_screenData.end()) {
332​ ScreenData screenData;
333​ m_screenData.prepend(screenData);
334​ screenDataIt = m_screenData.begin();
335​ }
336​ screenDataIt->id = screen;
337​ auto it = corners.begin();
338​ screenDataIt->quad.clear();
339​ for (int i = 0; i < 4; i++) {
340​ float x = *it++;
341​ float y = *it++;
342​ screenDataIt->quad.append(QPointF(x, y));
343​ }
344​ }
345​
346​ slotScreenGeometryChanged(QSize());
347​
348​ return true;
349​}
350​
351​} // namespace
352​