2020-08-02 22:22:19 +00:00
|
|
|
/*
|
|
|
|
KWin - the KDE window manager
|
|
|
|
This file is part of the KDE project.
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-FileCopyrightText: 2006 Lubos Lunak <l.lunak@kde.org>
|
|
|
|
SPDX-FileCopyrightText: 2009, 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
|
|
|
|
SPDX-FileCopyrightText: 2019 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
Based on glcompmgr code by Felix Bellaby.
|
|
|
|
Using code from Compiz and Beryl.
|
2007-11-27 19:40:25 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
Explicit command stream synchronization based on the sample
|
|
|
|
implementation by James Jones <jajones@nvidia.com>,
|
2014-09-03 16:43:38 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-FileCopyrightText: 2011 NVIDIA Corporation
|
2014-09-03 16:43:38 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
*/
|
2007-04-29 17:35:43 +00:00
|
|
|
#include "scene_opengl.h"
|
2021-01-05 19:23:37 +00:00
|
|
|
#include "texture.h"
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2016-04-07 07:24:17 +00:00
|
|
|
#include "platform.h"
|
2015-03-27 07:51:56 +00:00
|
|
|
#include "wayland_server.h"
|
|
|
|
|
2011-02-19 08:58:44 +00:00
|
|
|
#include <kwinglplatform.h>
|
[libkwineffects] Introduce API to easily show a QtQuick scene in an effect
Summary:
EffectQuickView/Scene is a convenient class to render a QtQuick
scenegraph into an effect.
Current methods (such as present windows) involve creating an underlying
platform window which is expensive, causes a headache to filter out
again in the rest of the code, and only works as an overlay.
The new class exposes things more natively to an effect where we don't
mess with real windows, we can perform the painting anywhere in the view
and we don't have issues with hiding/closing.
QtQuick has both software and hardware accelerated modes, and kwin also
has 3 render backends. Every combination is supported.
* When used in OpenGL mode for both, we render into an FBO export the
texture ID then it's up to the effect to render that into a scene.
* When using software QtQuick rendering we blit into an image, upload
that into a KWinGLTexture which serves as an abstraction layer and
render that into the scene.
* When using GL for QtQuick and XRender/QPainter in kwin everything is
rendered into the internal FBO, blit and exported as an image.
* When using software rendering for both an image gets passed directly.
Mouse and keyboard events can be forwarded, only if the effect
intercepts them.
The class is meant to be generic enough that we can remove all the
QtQuick code from Aurorae.
The intention is also to replace EffectFrameImpl using this backend and
we can kill all of the EffectFrame code throughout the scenes.
The close button in present windows will also be ported to this,
simplifiying that code base.
Classes that handle the rendering and handling QML are intentionally
split so that in the future we can have a declarative effects API create
overlays from within the same context. Similar to how one can
instantiate windows from a typical QML scene.
Notes:
I don't like how I pass the kwin GL context from the backends into the
effect, but I need something that works with the library separation. It
also currently has wayland problem if I create a QOpenGLContext before
the QPA is set up with a scene - but I don't have anything better?
I know for the EffectFrame we need an API to push things through the
effects stack to handle blur/invert etc. Will deal with that when we
port the EffectFrame.
Test Plan: Used in an effect
Reviewers: #kwin, zzag
Reviewed By: #kwin, zzag
Subscribers: zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D24215
2019-09-27 15:06:37 +00:00
|
|
|
#include <kwineffectquickview.h>
|
2010-11-14 19:49:00 +00:00
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
#include "utils.h"
|
2019-09-24 08:48:08 +00:00
|
|
|
#include "x11client.h"
|
2012-10-05 16:00:49 +00:00
|
|
|
#include "composite.h"
|
2007-04-29 17:35:43 +00:00
|
|
|
#include "deleted.h"
|
|
|
|
#include "effects.h"
|
2012-11-13 20:41:02 +00:00
|
|
|
#include "lanczosfilter.h"
|
2013-06-25 07:53:45 +00:00
|
|
|
#include "main.h"
|
2011-07-06 09:58:23 +00:00
|
|
|
#include "overlaywindow.h"
|
2021-01-26 12:18:29 +00:00
|
|
|
#include "renderloop.h"
|
2013-04-03 10:19:27 +00:00
|
|
|
#include "screens.h"
|
2017-06-12 20:28:39 +00:00
|
|
|
#include "cursor.h"
|
2014-07-22 11:11:19 +00:00
|
|
|
#include "decorations/decoratedclient.h"
|
2017-09-08 20:30:18 +00:00
|
|
|
#include <logging.h>
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2020-04-29 15:18:41 +00:00
|
|
|
#include <KWaylandServer/buffer_interface.h>
|
|
|
|
#include <KWaylandServer/subcompositor_interface.h>
|
|
|
|
#include <KWaylandServer/surface_interface.h>
|
2016-03-31 13:00:48 +00:00
|
|
|
|
2015-01-17 08:34:40 +00:00
|
|
|
#include <array>
|
2013-08-05 13:12:08 +00:00
|
|
|
#include <cmath>
|
2019-07-09 19:19:26 +00:00
|
|
|
#include <cstddef>
|
2013-05-19 14:45:06 +00:00
|
|
|
#include <unistd.h>
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2012-10-16 20:41:21 +00:00
|
|
|
#include <QDBusConnection>
|
|
|
|
#include <QDBusConnectionInterface>
|
|
|
|
#include <QDBusInterface>
|
2013-02-26 07:02:27 +00:00
|
|
|
#include <QGraphicsScale>
|
2019-07-09 19:19:26 +00:00
|
|
|
#include <QPainter>
|
2012-10-16 20:41:21 +00:00
|
|
|
#include <QStringList>
|
2010-11-14 19:49:00 +00:00
|
|
|
#include <QVector2D>
|
|
|
|
#include <QVector4D>
|
2010-12-04 11:31:18 +00:00
|
|
|
#include <QMatrix4x4>
|
2008-08-29 19:02:36 +00:00
|
|
|
|
2014-03-17 15:24:10 +00:00
|
|
|
#include <KLocalizedString>
|
|
|
|
#include <KNotification>
|
2012-10-16 20:41:21 +00:00
|
|
|
#include <KProcess>
|
|
|
|
|
2015-11-03 09:12:55 +00:00
|
|
|
// HACK: workaround for libepoxy < 1.3
|
|
|
|
#ifndef GL_GUILTY_CONTEXT_RESET
|
|
|
|
#define GL_GUILTY_CONTEXT_RESET 0x8253
|
|
|
|
#endif
|
|
|
|
#ifndef GL_INNOCENT_CONTEXT_RESET
|
|
|
|
#define GL_INNOCENT_CONTEXT_RESET 0x8254
|
|
|
|
#endif
|
|
|
|
#ifndef GL_UNKNOWN_CONTEXT_RESET
|
|
|
|
#define GL_UNKNOWN_CONTEXT_RESET 0x8255
|
|
|
|
#endif
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
namespace KWin
|
|
|
|
{
|
|
|
|
|
2014-09-03 16:43:38 +00:00
|
|
|
/**
|
|
|
|
* SyncObject represents a fence used to synchronize operations in
|
|
|
|
* the kwin command stream with operations in the X command stream.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2014-09-03 16:43:38 +00:00
|
|
|
class SyncObject
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
enum State { Ready, TriggerSent, Waiting, Done, Resetting };
|
|
|
|
|
|
|
|
SyncObject();
|
|
|
|
~SyncObject();
|
|
|
|
|
|
|
|
State state() const { return m_state; }
|
|
|
|
|
|
|
|
void trigger();
|
|
|
|
void wait();
|
|
|
|
bool finish();
|
|
|
|
void reset();
|
|
|
|
void finishResetting();
|
|
|
|
|
|
|
|
private:
|
|
|
|
State m_state;
|
|
|
|
GLsync m_sync;
|
|
|
|
xcb_sync_fence_t m_fence;
|
|
|
|
xcb_get_input_focus_cookie_t m_reset_cookie;
|
|
|
|
};
|
|
|
|
|
|
|
|
SyncObject::SyncObject()
|
|
|
|
{
|
|
|
|
m_state = Ready;
|
|
|
|
|
|
|
|
xcb_connection_t * const c = connection();
|
|
|
|
|
|
|
|
m_fence = xcb_generate_id(c);
|
|
|
|
xcb_sync_create_fence(c, rootWindow(), m_fence, false);
|
|
|
|
xcb_flush(c);
|
|
|
|
|
|
|
|
m_sync = glImportSyncEXT(GL_SYNC_X11_FENCE_EXT, m_fence, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
SyncObject::~SyncObject()
|
|
|
|
{
|
2015-03-21 00:18:46 +00:00
|
|
|
// If glDeleteSync is called before the xcb fence is signalled
|
|
|
|
// the nvidia driver (the only one to implement GL_SYNC_X11_FENCE_EXT)
|
|
|
|
// deadlocks waiting for the fence to be signalled.
|
|
|
|
// To avoid this, make sure the fence is signalled before
|
|
|
|
// deleting the sync.
|
|
|
|
if (m_state == Resetting || m_state == Ready){
|
|
|
|
trigger();
|
|
|
|
// The flush is necessary!
|
|
|
|
// The trigger command needs to be sent to the X server.
|
|
|
|
xcb_flush(connection());
|
|
|
|
}
|
2014-09-03 16:43:38 +00:00
|
|
|
xcb_sync_destroy_fence(connection(), m_fence);
|
|
|
|
glDeleteSync(m_sync);
|
|
|
|
|
|
|
|
if (m_state == Resetting)
|
|
|
|
xcb_discard_reply(connection(), m_reset_cookie.sequence);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SyncObject::trigger()
|
|
|
|
{
|
2019-08-31 14:28:37 +00:00
|
|
|
Q_ASSERT(m_state == Ready || m_state == Resetting);
|
2014-09-03 16:43:38 +00:00
|
|
|
|
|
|
|
// Finish resetting the fence if necessary
|
|
|
|
if (m_state == Resetting)
|
|
|
|
finishResetting();
|
|
|
|
|
|
|
|
xcb_sync_trigger_fence(connection(), m_fence);
|
|
|
|
m_state = TriggerSent;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SyncObject::wait()
|
|
|
|
{
|
|
|
|
if (m_state != TriggerSent)
|
|
|
|
return;
|
|
|
|
|
|
|
|
glWaitSync(m_sync, 0, GL_TIMEOUT_IGNORED);
|
|
|
|
m_state = Waiting;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SyncObject::finish()
|
|
|
|
{
|
|
|
|
if (m_state == Done)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Note: It is possible that we never inserted a wait for the fence.
|
|
|
|
// This can happen if we ended up not rendering the damaged
|
|
|
|
// window because it is fully occluded.
|
2019-08-31 14:28:37 +00:00
|
|
|
Q_ASSERT(m_state == TriggerSent || m_state == Waiting);
|
2014-09-03 16:43:38 +00:00
|
|
|
|
|
|
|
// Check if the fence is signaled
|
|
|
|
GLint value;
|
|
|
|
glGetSynciv(m_sync, GL_SYNC_STATUS, 1, nullptr, &value);
|
|
|
|
|
|
|
|
if (value != GL_SIGNALED) {
|
2017-09-08 20:30:18 +00:00
|
|
|
qCDebug(KWIN_OPENGL) << "Waiting for X fence to finish";
|
2014-09-03 16:43:38 +00:00
|
|
|
|
|
|
|
// Wait for the fence to become signaled with a one second timeout
|
|
|
|
const GLenum result = glClientWaitSync(m_sync, 0, 1000000000);
|
|
|
|
|
|
|
|
switch (result) {
|
|
|
|
case GL_TIMEOUT_EXPIRED:
|
2017-09-08 20:30:18 +00:00
|
|
|
qCWarning(KWIN_OPENGL) << "Timeout while waiting for X fence";
|
2014-09-03 16:43:38 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
case GL_WAIT_FAILED:
|
2017-09-08 20:30:18 +00:00
|
|
|
qCWarning(KWIN_OPENGL) << "glClientWaitSync() failed";
|
2014-09-03 16:43:38 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
m_state = Done;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SyncObject::reset()
|
|
|
|
{
|
2019-08-31 14:28:37 +00:00
|
|
|
Q_ASSERT(m_state == Done);
|
2014-09-03 16:43:38 +00:00
|
|
|
|
|
|
|
xcb_connection_t * const c = connection();
|
|
|
|
|
|
|
|
// Send the reset request along with a sync request.
|
|
|
|
// We use the cookie to ensure that the server has processed the reset
|
|
|
|
// request before we trigger the fence and call glWaitSync().
|
|
|
|
// Otherwise there is a race condition between the reset finishing and
|
|
|
|
// the glWaitSync() call.
|
|
|
|
xcb_sync_reset_fence(c, m_fence);
|
|
|
|
m_reset_cookie = xcb_get_input_focus(c);
|
|
|
|
xcb_flush(c);
|
|
|
|
|
|
|
|
m_state = Resetting;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SyncObject::finishResetting()
|
|
|
|
{
|
2019-08-31 14:28:37 +00:00
|
|
|
Q_ASSERT(m_state == Resetting);
|
2014-09-03 16:43:38 +00:00
|
|
|
free(xcb_get_input_focus_reply(connection(), m_reset_cookie, nullptr));
|
|
|
|
m_state = Ready;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* SyncManager manages a set of fences used for explicit synchronization
|
|
|
|
* with the X command stream.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2014-09-03 16:43:38 +00:00
|
|
|
class SyncManager
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
enum { MaxFences = 4 };
|
|
|
|
|
|
|
|
SyncManager();
|
|
|
|
~SyncManager();
|
|
|
|
|
|
|
|
SyncObject *nextFence();
|
|
|
|
bool updateFences();
|
|
|
|
|
|
|
|
private:
|
|
|
|
std::array<SyncObject, MaxFences> m_fences;
|
|
|
|
int m_next;
|
|
|
|
};
|
|
|
|
|
|
|
|
SyncManager::SyncManager()
|
|
|
|
: m_next(0)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
SyncManager::~SyncManager()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
SyncObject *SyncManager::nextFence()
|
|
|
|
{
|
|
|
|
SyncObject *fence = &m_fences[m_next];
|
|
|
|
m_next = (m_next + 1) % MaxFences;
|
|
|
|
return fence;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SyncManager::updateFences()
|
|
|
|
{
|
|
|
|
for (int i = 0; i < qMin(2, MaxFences - 1); i++) {
|
|
|
|
const int index = (m_next + i) % MaxFences;
|
|
|
|
SyncObject &fence = m_fences[index];
|
|
|
|
|
|
|
|
switch (fence.state()) {
|
|
|
|
case SyncObject::Ready:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SyncObject::TriggerSent:
|
|
|
|
case SyncObject::Waiting:
|
|
|
|
if (!fence.finish())
|
|
|
|
return false;
|
|
|
|
fence.reset();
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Should not happen in practice since we always reset the fence
|
|
|
|
// after finishing it
|
|
|
|
case SyncObject::Done:
|
|
|
|
fence.reset();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SyncObject::Resetting:
|
|
|
|
fence.finishResetting();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
|
2012-08-26 15:14:23 +00:00
|
|
|
/************************************************
|
|
|
|
* SceneOpenGL
|
|
|
|
***********************************************/
|
|
|
|
|
2015-02-23 13:41:45 +00:00
|
|
|
SceneOpenGL::SceneOpenGL(OpenGLBackend *backend, QObject *parent)
|
|
|
|
: Scene(parent)
|
2012-11-22 14:08:48 +00:00
|
|
|
, init_ok(true)
|
2012-09-06 15:13:22 +00:00
|
|
|
, m_backend(backend)
|
2014-09-03 16:43:38 +00:00
|
|
|
, m_syncManager(nullptr)
|
|
|
|
, m_currentFence(nullptr)
|
2012-08-26 15:14:23 +00:00
|
|
|
{
|
|
|
|
if (m_backend->isFailed()) {
|
2012-11-22 14:08:48 +00:00
|
|
|
init_ok = false;
|
2012-08-26 15:14:23 +00:00
|
|
|
return;
|
|
|
|
}
|
2014-11-25 07:40:23 +00:00
|
|
|
if (!viewportLimitsMatched(screens()->size()))
|
2012-10-16 20:41:21 +00:00
|
|
|
return;
|
2012-08-26 15:14:23 +00:00
|
|
|
|
|
|
|
// perform Scene specific checks
|
|
|
|
GLPlatform *glPlatform = GLPlatform::instance();
|
2015-10-30 11:34:39 +00:00
|
|
|
if (!glPlatform->isGLES() && !hasGLExtension(QByteArrayLiteral("GL_ARB_texture_non_power_of_two"))
|
2014-02-11 18:35:54 +00:00
|
|
|
&& !hasGLExtension(QByteArrayLiteral("GL_ARB_texture_rectangle"))) {
|
2017-09-08 20:30:18 +00:00
|
|
|
qCCritical(KWIN_OPENGL) << "GL_ARB_texture_non_power_of_two and GL_ARB_texture_rectangle missing";
|
2012-11-22 14:08:48 +00:00
|
|
|
init_ok = false;
|
2012-08-26 15:14:23 +00:00
|
|
|
return; // error
|
|
|
|
}
|
2017-07-01 16:14:52 +00:00
|
|
|
if (glPlatform->isMesaDriver() && glPlatform->mesaVersion() < kVersionNumber(10, 0)) {
|
2017-09-08 20:30:18 +00:00
|
|
|
qCCritical(KWIN_OPENGL) << "KWin requires at least Mesa 10.0 for OpenGL compositing.";
|
2012-11-22 14:08:48 +00:00
|
|
|
init_ok = false;
|
2012-08-26 15:14:23 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-03-17 11:58:36 +00:00
|
|
|
m_debug = qstrcmp(qgetenv("KWIN_GL_DEBUG"), "1") == 0;
|
2014-11-19 18:01:55 +00:00
|
|
|
initDebugOutput();
|
2012-08-26 15:14:23 +00:00
|
|
|
|
|
|
|
// set strict binding
|
|
|
|
if (options->isGlStrictBindingFollowsDriver()) {
|
|
|
|
options->setGlStrictBinding(!glPlatform->supports(LooseBinding));
|
|
|
|
}
|
2014-09-03 16:43:38 +00:00
|
|
|
|
|
|
|
bool haveSyncObjects = glPlatform->isGLES()
|
|
|
|
? hasGLVersion(3, 0)
|
|
|
|
: hasGLVersion(3, 2) || hasGLExtension("GL_ARB_sync");
|
|
|
|
|
2017-08-24 14:18:24 +00:00
|
|
|
if (hasGLExtension("GL_EXT_x11_sync_object") && haveSyncObjects && kwinApp()->operationMode() == Application::OperationModeX11) {
|
2014-09-03 16:43:38 +00:00
|
|
|
const QByteArray useExplicitSync = qgetenv("KWIN_EXPLICIT_SYNC");
|
|
|
|
|
|
|
|
if (useExplicitSync != "0") {
|
2017-09-08 20:30:18 +00:00
|
|
|
qCDebug(KWIN_OPENGL) << "Initializing fences for synchronization with the X command stream";
|
2014-09-03 16:43:38 +00:00
|
|
|
m_syncManager = new SyncManager;
|
|
|
|
} else {
|
2017-09-08 20:30:18 +00:00
|
|
|
qCDebug(KWIN_OPENGL) << "Explicit synchronization with the X command stream disabled by environment variable";
|
2014-09-03 16:43:38 +00:00
|
|
|
}
|
|
|
|
}
|
2012-08-26 15:14:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SceneOpenGL::~SceneOpenGL()
|
|
|
|
{
|
2019-04-22 07:34:49 +00:00
|
|
|
if (init_ok) {
|
|
|
|
makeOpenGLContextCurrent();
|
2012-09-06 15:13:22 +00:00
|
|
|
}
|
2019-04-22 07:34:49 +00:00
|
|
|
SceneOpenGL::EffectFrame::cleanup();
|
|
|
|
|
|
|
|
delete m_syncManager;
|
|
|
|
|
|
|
|
// backend might be still needed for a different scene
|
|
|
|
delete m_backend;
|
2012-08-26 15:14:23 +00:00
|
|
|
}
|
|
|
|
|
2015-05-26 20:52:16 +00:00
|
|
|
|
2014-11-19 18:01:55 +00:00
|
|
|
void SceneOpenGL::initDebugOutput()
|
|
|
|
{
|
|
|
|
const bool have_KHR_debug = hasGLExtension(QByteArrayLiteral("GL_KHR_debug"));
|
2015-11-13 12:11:47 +00:00
|
|
|
const bool have_ARB_debug = hasGLExtension(QByteArrayLiteral("GL_ARB_debug_output"));
|
|
|
|
if (!have_KHR_debug && !have_ARB_debug)
|
2014-11-19 18:01:55 +00:00
|
|
|
return;
|
|
|
|
|
2015-11-13 12:11:47 +00:00
|
|
|
if (!have_ARB_debug) {
|
|
|
|
// if we don't have ARB debug, but only KHR debug we need to verify whether the context is a debug context
|
|
|
|
// it should work without as well, but empirical tests show: no it doesn't
|
|
|
|
if (GLPlatform::instance()->isGLES()) {
|
|
|
|
if (!hasGLVersion(3, 2)) {
|
|
|
|
// empirical data shows extension doesn't work
|
|
|
|
return;
|
|
|
|
}
|
2015-11-19 10:20:33 +00:00
|
|
|
} else if (!hasGLVersion(3, 0)) {
|
|
|
|
return;
|
2015-11-13 12:11:47 +00:00
|
|
|
}
|
2015-11-19 10:20:33 +00:00
|
|
|
// can only be queried with either OpenGL >= 3.0 or OpenGL ES of at least 3.1
|
2015-11-13 12:11:47 +00:00
|
|
|
GLint value = 0;
|
|
|
|
glGetIntegerv(GL_CONTEXT_FLAGS, &value);
|
|
|
|
if (!(value & GL_CONTEXT_FLAG_DEBUG_BIT)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-19 18:01:55 +00:00
|
|
|
// Set the callback function
|
|
|
|
auto callback = [](GLenum source, GLenum type, GLuint id,
|
|
|
|
GLenum severity, GLsizei length,
|
|
|
|
const GLchar *message,
|
|
|
|
const GLvoid *userParam) {
|
|
|
|
Q_UNUSED(source)
|
|
|
|
Q_UNUSED(severity)
|
|
|
|
Q_UNUSED(userParam)
|
2020-05-15 10:24:36 +00:00
|
|
|
while (length && std::isspace(message[length - 1])) {
|
2015-07-20 11:35:45 +00:00
|
|
|
--length;
|
2020-05-15 10:24:36 +00:00
|
|
|
}
|
2014-11-19 18:01:55 +00:00
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case GL_DEBUG_TYPE_ERROR:
|
|
|
|
case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
|
2017-09-08 20:30:18 +00:00
|
|
|
qCWarning(KWIN_OPENGL, "%#x: %.*s", id, length, message);
|
2014-11-19 18:01:55 +00:00
|
|
|
break;
|
|
|
|
|
2015-05-26 20:52:16 +00:00
|
|
|
case GL_DEBUG_TYPE_OTHER:
|
2014-11-19 18:01:55 +00:00
|
|
|
case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
|
|
|
|
case GL_DEBUG_TYPE_PORTABILITY:
|
|
|
|
case GL_DEBUG_TYPE_PERFORMANCE:
|
|
|
|
default:
|
2017-09-08 20:30:18 +00:00
|
|
|
qCDebug(KWIN_OPENGL, "%#x: %.*s", id, length, message);
|
2014-11-19 18:01:55 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
glDebugMessageCallback(callback, nullptr);
|
|
|
|
|
|
|
|
// This state exists only in GL_KHR_debug
|
|
|
|
if (have_KHR_debug)
|
|
|
|
glEnable(GL_DEBUG_OUTPUT);
|
|
|
|
|
2019-08-31 14:28:37 +00:00
|
|
|
#if !defined(QT_NO_DEBUG)
|
2014-11-19 18:01:55 +00:00
|
|
|
// Enable all debug messages
|
|
|
|
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
|
|
|
|
#else
|
|
|
|
// Enable error messages
|
|
|
|
glDebugMessageControl(GL_DONT_CARE, GL_DEBUG_TYPE_ERROR, GL_DONT_CARE, 0, nullptr, GL_TRUE);
|
|
|
|
glDebugMessageControl(GL_DONT_CARE, GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR, GL_DONT_CARE, 0, nullptr, GL_TRUE);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Insert a test message
|
|
|
|
const QByteArray message = QByteArrayLiteral("OpenGL debug output initialized");
|
|
|
|
glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_OTHER, 0,
|
|
|
|
GL_DEBUG_SEVERITY_LOW, message.length(), message.constData());
|
|
|
|
}
|
|
|
|
|
2015-02-23 13:41:45 +00:00
|
|
|
SceneOpenGL *SceneOpenGL::createScene(QObject *parent)
|
2012-09-06 15:13:22 +00:00
|
|
|
{
|
2016-04-12 13:03:07 +00:00
|
|
|
OpenGLBackend *backend = kwinApp()->platform()->createOpenGLBackend();
|
2015-11-25 12:09:28 +00:00
|
|
|
if (!backend) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
if (!backend->isFailed()) {
|
|
|
|
backend->init();
|
|
|
|
}
|
|
|
|
if (backend->isFailed()) {
|
2012-09-06 15:13:22 +00:00
|
|
|
delete backend;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
return nullptr;
|
2012-09-06 15:13:22 +00:00
|
|
|
}
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
SceneOpenGL *scene = nullptr;
|
2012-09-06 15:13:22 +00:00
|
|
|
// first let's try an OpenGL 2 scene
|
|
|
|
if (SceneOpenGL2::supported(backend)) {
|
2015-02-23 13:41:45 +00:00
|
|
|
scene = new SceneOpenGL2(backend, parent);
|
2012-09-06 15:13:22 +00:00
|
|
|
if (scene->initFailed()) {
|
|
|
|
delete scene;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
scene = nullptr;
|
2012-09-06 15:13:22 +00:00
|
|
|
} else {
|
|
|
|
return scene;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!scene) {
|
2012-10-05 16:00:49 +00:00
|
|
|
if (GLPlatform::instance()->recommendedCompositor() == XRenderCompositing) {
|
2017-09-08 20:30:18 +00:00
|
|
|
qCCritical(KWIN_OPENGL) << "OpenGL driver recommends XRender based compositing. Falling back to XRender.";
|
|
|
|
qCCritical(KWIN_OPENGL) << "To overwrite the detection use the environment variable KWIN_COMPOSE";
|
2019-03-25 18:11:15 +00:00
|
|
|
qCCritical(KWIN_OPENGL) << "For more information see https://community.kde.org/KWin/Environment_Variables#KWIN_COMPOSE";
|
2012-10-05 16:00:49 +00:00
|
|
|
}
|
2012-09-06 15:13:22 +00:00
|
|
|
delete backend;
|
|
|
|
}
|
|
|
|
|
|
|
|
return scene;
|
|
|
|
}
|
|
|
|
|
2019-08-07 17:33:20 +00:00
|
|
|
OverlayWindow *SceneOpenGL::overlayWindow() const
|
2012-08-26 15:14:23 +00:00
|
|
|
{
|
|
|
|
return m_backend->overlayWindow();
|
|
|
|
}
|
|
|
|
|
2007-05-30 14:22:09 +00:00
|
|
|
bool SceneOpenGL::initFailed() const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2007-05-30 14:22:09 +00:00
|
|
|
return !init_ok;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-05-30 14:22:09 +00:00
|
|
|
|
2013-05-19 14:45:06 +00:00
|
|
|
void SceneOpenGL::handleGraphicsReset(GLenum status)
|
|
|
|
{
|
|
|
|
switch (status) {
|
2015-10-30 11:34:39 +00:00
|
|
|
case GL_GUILTY_CONTEXT_RESET:
|
2017-09-08 20:30:18 +00:00
|
|
|
qCDebug(KWIN_OPENGL) << "A graphics reset attributable to the current GL context occurred.";
|
2013-05-19 14:45:06 +00:00
|
|
|
break;
|
|
|
|
|
2015-10-30 11:34:39 +00:00
|
|
|
case GL_INNOCENT_CONTEXT_RESET:
|
2017-09-08 20:30:18 +00:00
|
|
|
qCDebug(KWIN_OPENGL) << "A graphics reset not attributable to the current GL context occurred.";
|
2013-05-19 14:45:06 +00:00
|
|
|
break;
|
|
|
|
|
2015-10-30 11:34:39 +00:00
|
|
|
case GL_UNKNOWN_CONTEXT_RESET:
|
2017-09-08 20:30:18 +00:00
|
|
|
qCDebug(KWIN_OPENGL) << "A graphics reset of an unknown cause occurred.";
|
2013-05-19 14:45:06 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
QElapsedTimer timer;
|
|
|
|
timer.start();
|
|
|
|
|
|
|
|
// Wait until the reset is completed or max 10 seconds
|
2015-11-17 10:00:53 +00:00
|
|
|
while (timer.elapsed() < 10000 && glGetGraphicsResetStatus() != GL_NO_ERROR)
|
2013-05-19 14:45:06 +00:00
|
|
|
usleep(50);
|
|
|
|
|
2017-09-08 20:30:18 +00:00
|
|
|
qCDebug(KWIN_OPENGL) << "Attempting to reset compositing.";
|
2013-05-19 14:45:06 +00:00
|
|
|
QMetaObject::invokeMethod(this, "resetCompositing", Qt::QueuedConnection);
|
|
|
|
|
2013-07-23 05:02:52 +00:00
|
|
|
KNotification::event(QStringLiteral("graphicsreset"), i18n("Desktop effects were restarted due to a graphics reset"));
|
2020-11-09 14:10:03 +00:00
|
|
|
|
|
|
|
m_resetOccurred = true;
|
2013-05-19 14:45:06 +00:00
|
|
|
}
|
|
|
|
|
2014-09-03 16:43:38 +00:00
|
|
|
|
|
|
|
void SceneOpenGL::triggerFence()
|
|
|
|
{
|
|
|
|
if (m_syncManager) {
|
|
|
|
m_currentFence = m_syncManager->nextFence();
|
|
|
|
m_currentFence->trigger();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SceneOpenGL::insertWait()
|
|
|
|
{
|
|
|
|
if (m_currentFence && m_currentFence->state() != SyncObject::Waiting) {
|
|
|
|
m_currentFence->wait();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-12 20:28:39 +00:00
|
|
|
/**
|
|
|
|
* Render cursor texture in case hardware cursor is disabled.
|
|
|
|
* Useful for screen recording apps or backends that can't do planes.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2020-10-26 07:39:55 +00:00
|
|
|
void SceneOpenGL2::paintCursor(const QRegion &rendered)
|
2017-06-12 20:28:39 +00:00
|
|
|
{
|
2020-04-02 16:18:01 +00:00
|
|
|
Cursor* cursor = Cursors::self()->currentCursor();
|
|
|
|
|
2019-03-19 19:46:16 +00:00
|
|
|
// don't paint if we use hardware cursor or the cursor is hidden
|
|
|
|
if (!kwinApp()->platform()->usesSoftwareCursor() ||
|
|
|
|
kwinApp()->platform()->isCursorHidden() ||
|
2020-04-02 16:18:01 +00:00
|
|
|
cursor->image().isNull()) {
|
2017-06-12 20:28:39 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-10-26 07:39:55 +00:00
|
|
|
// figure out which part of the cursor needs to be repainted
|
|
|
|
const QPoint cursorPos = cursor->pos() - cursor->hotspot();
|
2020-10-25 15:19:07 +00:00
|
|
|
const QRect cursorRect = cursor->rect();
|
2020-10-26 07:39:55 +00:00
|
|
|
QRegion region;
|
|
|
|
for (const QRect &rect : rendered) {
|
|
|
|
region |= rect.translated(-cursorPos).intersected(cursorRect);
|
|
|
|
}
|
|
|
|
if (region.isEmpty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-06-12 20:28:39 +00:00
|
|
|
// lazy init texture cursor only in case we need software rendering
|
|
|
|
if (!m_cursorTexture) {
|
|
|
|
auto updateCursorTexture = [this] {
|
|
|
|
// don't paint if no image for cursor is set
|
2020-04-02 16:18:01 +00:00
|
|
|
const QImage img = Cursors::self()->currentCursor()->image();
|
2017-06-12 20:28:39 +00:00
|
|
|
if (img.isNull()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
m_cursorTexture.reset(new GLTexture(img));
|
2020-10-28 16:48:44 +00:00
|
|
|
m_cursorTexture->setWrapMode(GL_CLAMP_TO_EDGE);
|
2017-06-12 20:28:39 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
// init now
|
|
|
|
updateCursorTexture();
|
|
|
|
|
|
|
|
// handle shape update on case cursor image changed
|
2020-04-02 16:18:01 +00:00
|
|
|
connect(Cursors::self(), &Cursors::currentCursorChanged, this, updateCursorTexture);
|
2017-06-12 20:28:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// get cursor position in projection coordinates
|
|
|
|
QMatrix4x4 mvp = m_projectionMatrix;
|
|
|
|
mvp.translate(cursorPos.x(), cursorPos.y());
|
|
|
|
|
|
|
|
// handle transparence
|
|
|
|
glEnable(GL_BLEND);
|
|
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
|
|
|
|
|
|
// paint texture in cursor offset
|
|
|
|
m_cursorTexture->bind();
|
|
|
|
ShaderBinder binder(ShaderTrait::MapTexture);
|
|
|
|
binder.shader()->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
|
2020-10-26 07:39:55 +00:00
|
|
|
m_cursorTexture->render(region, cursorRect);
|
2017-06-12 20:28:39 +00:00
|
|
|
m_cursorTexture->unbind();
|
|
|
|
glDisable(GL_BLEND);
|
|
|
|
}
|
|
|
|
|
2020-10-30 07:39:17 +00:00
|
|
|
void SceneOpenGL::aboutToStartPainting(int screenId, const QRegion &damage)
|
2020-04-24 17:11:41 +00:00
|
|
|
{
|
2020-10-30 07:39:17 +00:00
|
|
|
m_backend->aboutToStartPainting(screenId, damage);
|
2020-04-24 17:11:41 +00:00
|
|
|
}
|
|
|
|
|
Provide expected presentation time to effects
Effects are given the interval between two consecutive frames. The main
flaw of this approach is that if the Compositor transitions from the idle
state to "active" state, i.e. when there is something to repaint,
effects may see a very large interval between the last painted frame and
the current. In order to address this issue, the Scene invalidates the
timer that is used to measure time between consecutive frames before the
Compositor is about to become idle.
While this works perfectly fine with Xinerama-style rendering, with per
screen rendering, determining whether the compositor is about to idle is
rather a tedious task mostly because a single output can't be used for
the test.
Furthermore, since the Compositor schedules pointless repaints just to
ensure that it's idle, it might take several attempts to figure out
whether the scene timer must be invalidated if you use (true) per screen
rendering.
Ideally, all effects should use a timeline helper that is aware of the
underlying render loop and its timings. However, this option is off the
table because it will involve a lot of work to implement it.
Alternative and much simpler option is to pass the expected presentation
time to effects rather than time between consecutive frames. This means
that effects are responsible for determining how much animation timelines
have to be advanced. Typically, an effect would have to store the
presentation timestamp provided in either prePaint{Screen,Window} and
use it in the subsequent prePaint{Screen,Window} call to estimate the
amount of time passed between the next and the last frames.
Unfortunately, this is an API incompatible change. However, it shouldn't
take a lot of work to port third-party binary effects, which don't use the
AnimationEffect class, to the new API. On the bright side, we no longer
need to be concerned about the Compositor getting idle.
We do still try to determine whether the Compositor is about to idle,
primarily, because the OpenGL render backend swaps buffers on present,
but that will change with the ongoing compositing timing rework.
2020-11-20 15:44:04 +00:00
|
|
|
void SceneOpenGL::paint(int screenId, const QRegion &damage, const QList<Toplevel *> &toplevels,
|
2021-01-26 12:18:29 +00:00
|
|
|
RenderLoop *renderLoop)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2020-11-09 14:10:03 +00:00
|
|
|
if (m_resetOccurred) {
|
|
|
|
return; // A graphics reset has occurred, do nothing.
|
|
|
|
}
|
|
|
|
|
|
|
|
painted_screen = screenId;
|
2012-08-26 15:14:23 +00:00
|
|
|
// actually paint the frame, flushed with the NEXT frame
|
2013-06-24 07:53:11 +00:00
|
|
|
createStackingOrder(toplevels);
|
2012-08-26 15:14:23 +00:00
|
|
|
|
2020-11-09 14:10:03 +00:00
|
|
|
QRegion update;
|
|
|
|
QRegion valid;
|
|
|
|
QRegion repaint;
|
|
|
|
QRect geo;
|
|
|
|
qreal scaling;
|
|
|
|
if (screenId != -1) {
|
|
|
|
geo = screens()->geometry(screenId);
|
|
|
|
scaling = screens()->scale(screenId);
|
|
|
|
} else {
|
|
|
|
geo = screens()->geometry();
|
|
|
|
scaling = 1;
|
|
|
|
}
|
2015-04-23 07:55:49 +00:00
|
|
|
|
2021-02-02 15:03:43 +00:00
|
|
|
const GLenum status = glGetGraphicsResetStatus();
|
|
|
|
if (status != GL_NO_ERROR) {
|
|
|
|
handleGraphicsReset(status);
|
|
|
|
} else {
|
|
|
|
renderLoop->beginFrame();
|
|
|
|
|
|
|
|
bool directScanout = false;
|
|
|
|
if (m_backend->directScanoutAllowed(screenId)) {
|
|
|
|
EffectsHandlerImpl *implEffects = static_cast<EffectsHandlerImpl*>(effects);
|
|
|
|
if (!implEffects->blocksDirectScanout()) {
|
|
|
|
for (int i = stacking_order.count() - 1; i >= 0; i--) {
|
|
|
|
Window *window = stacking_order[i];
|
|
|
|
AbstractClient *c = dynamic_cast<AbstractClient*>(window->window());
|
|
|
|
if (!c) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (c->isOnScreen(screenId)) {
|
|
|
|
if (window->isOpaque() && c->isFullScreen()) {
|
|
|
|
auto pixmap = window->windowPixmap<WindowPixmap>();
|
|
|
|
if (!pixmap) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
pixmap->update();
|
|
|
|
pixmap = pixmap->topMostSurface();
|
|
|
|
// the subsurface has to be able to cover the whole window
|
|
|
|
if (pixmap->position() != QPoint(0, 0)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
directScanout = m_backend->scanout(screenId, pixmap->surface());
|
2021-02-02 13:26:43 +00:00
|
|
|
}
|
2021-02-02 15:03:43 +00:00
|
|
|
break;
|
2021-02-02 13:26:43 +00:00
|
|
|
}
|
|
|
|
}
|
2015-10-30 11:34:39 +00:00
|
|
|
}
|
2015-04-23 07:55:49 +00:00
|
|
|
}
|
2021-02-02 15:03:43 +00:00
|
|
|
if (directScanout) {
|
|
|
|
renderLoop->endFrame();
|
|
|
|
} else {
|
|
|
|
// prepare rendering makescontext current on the output
|
|
|
|
repaint = m_backend->beginFrame(screenId);
|
2021-02-02 13:26:43 +00:00
|
|
|
|
2021-02-02 15:03:43 +00:00
|
|
|
GLVertexBuffer::setVirtualScreenGeometry(geo);
|
|
|
|
GLRenderTarget::setVirtualScreenGeometry(geo);
|
|
|
|
GLVertexBuffer::setVirtualScreenScale(scaling);
|
|
|
|
GLRenderTarget::setVirtualScreenScale(scaling);
|
2021-02-02 13:26:43 +00:00
|
|
|
|
|
|
|
int mask = 0;
|
|
|
|
updateProjectionMatrix();
|
|
|
|
|
|
|
|
paintScreen(&mask, damage.intersected(geo), repaint, &update, &valid,
|
|
|
|
renderLoop, projectionMatrix(), geo, scaling); // call generic implementation
|
|
|
|
paintCursor(valid);
|
|
|
|
|
|
|
|
if (!GLPlatform::instance()->isGLES() && screenId == -1) {
|
|
|
|
const QSize &screenSize = screens()->size();
|
|
|
|
const QRegion displayRegion(0, 0, screenSize.width(), screenSize.height());
|
|
|
|
|
|
|
|
// copy dirty parts from front to backbuffer
|
|
|
|
if (!m_backend->supportsBufferAge() &&
|
|
|
|
options->glPreferBufferSwap() == Options::CopyFrontBuffer &&
|
|
|
|
valid != displayRegion) {
|
|
|
|
glReadBuffer(GL_FRONT);
|
|
|
|
m_backend->copyPixels(displayRegion - valid);
|
|
|
|
glReadBuffer(GL_BACK);
|
|
|
|
valid = displayRegion;
|
|
|
|
}
|
|
|
|
}
|
2013-11-21 09:44:06 +00:00
|
|
|
|
2021-02-02 13:26:43 +00:00
|
|
|
renderLoop->endFrame();
|
2021-01-26 12:18:29 +00:00
|
|
|
|
2021-02-02 13:26:43 +00:00
|
|
|
GLVertexBuffer::streamingBuffer()->endOfFrame();
|
|
|
|
m_backend->endFrame(screenId, valid, update);
|
|
|
|
GLVertexBuffer::streamingBuffer()->framePosted();
|
2014-12-03 18:41:38 +00:00
|
|
|
|
2021-02-02 13:26:43 +00:00
|
|
|
if (m_currentFence) {
|
|
|
|
if (!m_syncManager->updateFences()) {
|
|
|
|
qCDebug(KWIN_OPENGL) << "Aborting explicit synchronization with the X command stream.";
|
|
|
|
qCDebug(KWIN_OPENGL) << "Future frames will be rendered unsynchronized.";
|
|
|
|
delete m_syncManager;
|
|
|
|
m_syncManager = nullptr;
|
|
|
|
}
|
|
|
|
m_currentFence = nullptr;
|
2020-11-09 14:10:03 +00:00
|
|
|
}
|
2014-09-03 16:43:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-26 15:14:23 +00:00
|
|
|
// do cleanup
|
2013-06-24 07:53:11 +00:00
|
|
|
clearStackingOrder();
|
2012-08-26 15:14:23 +00:00
|
|
|
}
|
|
|
|
|
2011-02-17 17:37:43 +00:00
|
|
|
QMatrix4x4 SceneOpenGL::transformation(int mask, const ScreenPaintData &data) const
|
|
|
|
{
|
|
|
|
QMatrix4x4 matrix;
|
|
|
|
|
|
|
|
if (!(mask & PAINT_SCREEN_TRANSFORMED))
|
|
|
|
return matrix;
|
|
|
|
|
2012-05-28 12:45:46 +00:00
|
|
|
matrix.translate(data.translation());
|
2020-10-30 20:47:41 +00:00
|
|
|
const QVector3D scale = data.scale();
|
|
|
|
matrix.scale(scale.x(), scale.y(), scale.z());
|
2011-02-17 17:37:43 +00:00
|
|
|
|
2012-06-02 19:54:18 +00:00
|
|
|
if (data.rotationAngle() == 0.0)
|
2011-02-17 17:37:43 +00:00
|
|
|
return matrix;
|
|
|
|
|
|
|
|
// Apply the rotation
|
2012-05-27 17:28:02 +00:00
|
|
|
// cannot use data.rotation->applyTo(&matrix) as QGraphicsRotation uses projectedRotate to map back to 2D
|
2012-06-02 19:54:18 +00:00
|
|
|
matrix.translate(data.rotationOrigin());
|
|
|
|
const QVector3D axis = data.rotationAxis();
|
|
|
|
matrix.rotate(data.rotationAngle(), axis.x(), axis.y(), axis.z());
|
|
|
|
matrix.translate(-data.rotationOrigin());
|
2011-02-17 17:37:43 +00:00
|
|
|
|
|
|
|
return matrix;
|
|
|
|
}
|
|
|
|
|
2020-03-13 16:41:56 +00:00
|
|
|
void SceneOpenGL::paintBackground(const QRegion ®ion)
|
2011-01-02 08:46:30 +00:00
|
|
|
{
|
|
|
|
PaintClipper pc(region);
|
|
|
|
if (!PaintClipper::clip()) {
|
|
|
|
glClearColor(0, 0, 0, 1);
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (pc.clip() && pc.paintArea().isEmpty())
|
|
|
|
return; // no background to paint
|
|
|
|
QVector<float> verts;
|
|
|
|
for (PaintClipper::Iterator iterator; !iterator.isDone(); iterator.next()) {
|
|
|
|
QRect r = iterator.boundingRect();
|
|
|
|
verts << r.x() + r.width() << r.y();
|
|
|
|
verts << r.x() << r.y();
|
|
|
|
verts << r.x() << r.y() + r.height();
|
|
|
|
verts << r.x() << r.y() + r.height();
|
|
|
|
verts << r.x() + r.width() << r.y() + r.height();
|
|
|
|
verts << r.x() + r.width() << r.y();
|
|
|
|
}
|
2012-09-06 15:13:22 +00:00
|
|
|
doPaintBackground(verts);
|
2011-01-02 08:46:30 +00:00
|
|
|
}
|
|
|
|
|
2013-02-18 22:17:46 +00:00
|
|
|
void SceneOpenGL::extendPaintRegion(QRegion ®ion, bool opaqueFullscreen)
|
|
|
|
{
|
2013-11-21 09:44:06 +00:00
|
|
|
if (m_backend->supportsBufferAge())
|
|
|
|
return;
|
|
|
|
|
2014-11-25 07:40:23 +00:00
|
|
|
const QSize &screenSize = screens()->size();
|
2013-02-18 22:17:46 +00:00
|
|
|
if (options->glPreferBufferSwap() == Options::ExtendDamage) { // only Extend "large" repaints
|
2014-11-25 07:40:23 +00:00
|
|
|
const QRegion displayRegion(0, 0, screenSize.width(), screenSize.height());
|
2013-02-18 22:17:46 +00:00
|
|
|
uint damagedPixels = 0;
|
2014-11-25 07:40:23 +00:00
|
|
|
const uint fullRepaintLimit = (opaqueFullscreen?0.49f:0.748f)*screenSize.width()*screenSize.height();
|
2013-02-18 22:17:46 +00:00
|
|
|
// 16:9 is 75% of 4:3 and 2.55:1 is 49.01% of 5:4
|
|
|
|
// (5:4 is the most square format and 2.55:1 is Cinemascope55 - the widest ever shot
|
|
|
|
// movie aspect - two times ;-) It's a Fox format, though, so maybe we want to restrict
|
|
|
|
// to 2.20:1 - Panavision - which has actually been used for interesting movies ...)
|
|
|
|
// would be 57% of 5/4
|
2017-12-02 09:05:04 +00:00
|
|
|
for (const QRect &r : region) {
|
2013-02-18 22:17:46 +00:00
|
|
|
// damagedPixels += r.width() * r.height(); // combined window damage test
|
|
|
|
damagedPixels = r.width() * r.height(); // experimental single window damage testing
|
|
|
|
if (damagedPixels > fullRepaintLimit) {
|
|
|
|
region = displayRegion;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (options->glPreferBufferSwap() == Options::PaintFullScreen) { // forced full rePaint
|
2014-11-25 07:40:23 +00:00
|
|
|
region = QRegion(0, 0, screenSize.width(), screenSize.height());
|
2013-02-18 22:17:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-08 20:30:18 +00:00
|
|
|
SceneOpenGLTexture *SceneOpenGL::createTexture()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2017-09-08 20:30:18 +00:00
|
|
|
return new SceneOpenGLTexture(m_backend);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2012-10-16 20:41:21 +00:00
|
|
|
bool SceneOpenGL::viewportLimitsMatched(const QSize &size) const {
|
2019-08-07 17:33:20 +00:00
|
|
|
if (kwinApp()->operationMode() != Application::OperationModeX11) {
|
|
|
|
// TODO: On Wayland we can't suspend. Find a solution that works here as well!
|
|
|
|
return true;
|
|
|
|
}
|
2012-10-16 20:41:21 +00:00
|
|
|
GLint limit[2];
|
|
|
|
glGetIntegerv(GL_MAX_VIEWPORT_DIMS, limit);
|
|
|
|
if (limit[0] < size.width() || limit[1] < size.height()) {
|
2019-09-26 15:09:16 +00:00
|
|
|
auto compositor = static_cast<X11Compositor*>(Compositor::self());
|
|
|
|
QMetaObject::invokeMethod(compositor, [compositor]() {
|
2020-03-19 14:36:09 +00:00
|
|
|
qCDebug(KWIN_OPENGL) << "Suspending compositing because viewport limits are not met";
|
|
|
|
compositor->suspend(X11Compositor::AllReasonSuspend);
|
|
|
|
}, Qt::QueuedConnection);
|
2012-10-16 20:41:21 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-08-26 15:14:23 +00:00
|
|
|
void SceneOpenGL::screenGeometryChanged(const QSize &size)
|
2011-07-18 15:55:39 +00:00
|
|
|
{
|
2012-10-16 20:41:21 +00:00
|
|
|
if (!viewportLimitsMatched(size))
|
|
|
|
return;
|
2012-08-26 15:14:23 +00:00
|
|
|
Scene::screenGeometryChanged(size);
|
|
|
|
glViewport(0,0, size.width(), size.height());
|
|
|
|
m_backend->screenGeometryChanged(size);
|
2014-11-25 07:40:23 +00:00
|
|
|
GLRenderTarget::setVirtualScreenSize(size);
|
2012-09-06 15:13:22 +00:00
|
|
|
}
|
|
|
|
|
2012-03-29 18:17:57 +00:00
|
|
|
void SceneOpenGL::paintDesktop(int desktop, int mask, const QRegion ®ion, ScreenPaintData &data)
|
|
|
|
{
|
|
|
|
const QRect r = region.boundingRect();
|
|
|
|
glEnable(GL_SCISSOR_TEST);
|
2014-11-25 07:40:23 +00:00
|
|
|
glScissor(r.x(), screens()->size().height() - r.y() - r.height(), r.width(), r.height());
|
2012-03-29 18:17:57 +00:00
|
|
|
KWin::Scene::paintDesktop(desktop, mask, region, data);
|
|
|
|
glDisable(GL_SCISSOR_TEST);
|
|
|
|
}
|
|
|
|
|
[libkwineffects] Introduce API to easily show a QtQuick scene in an effect
Summary:
EffectQuickView/Scene is a convenient class to render a QtQuick
scenegraph into an effect.
Current methods (such as present windows) involve creating an underlying
platform window which is expensive, causes a headache to filter out
again in the rest of the code, and only works as an overlay.
The new class exposes things more natively to an effect where we don't
mess with real windows, we can perform the painting anywhere in the view
and we don't have issues with hiding/closing.
QtQuick has both software and hardware accelerated modes, and kwin also
has 3 render backends. Every combination is supported.
* When used in OpenGL mode for both, we render into an FBO export the
texture ID then it's up to the effect to render that into a scene.
* When using software QtQuick rendering we blit into an image, upload
that into a KWinGLTexture which serves as an abstraction layer and
render that into the scene.
* When using GL for QtQuick and XRender/QPainter in kwin everything is
rendered into the internal FBO, blit and exported as an image.
* When using software rendering for both an image gets passed directly.
Mouse and keyboard events can be forwarded, only if the effect
intercepts them.
The class is meant to be generic enough that we can remove all the
QtQuick code from Aurorae.
The intention is also to replace EffectFrameImpl using this backend and
we can kill all of the EffectFrame code throughout the scenes.
The close button in present windows will also be ported to this,
simplifiying that code base.
Classes that handle the rendering and handling QML are intentionally
split so that in the future we can have a declarative effects API create
overlays from within the same context. Similar to how one can
instantiate windows from a typical QML scene.
Notes:
I don't like how I pass the kwin GL context from the backends into the
effect, but I need something that works with the library separation. It
also currently has wayland problem if I create a QOpenGLContext before
the QPA is set up with a scene - but I don't have anything better?
I know for the EffectFrame we need an API to push things through the
effects stack to handle blur/invert etc. Will deal with that when we
port the EffectFrame.
Test Plan: Used in an effect
Reviewers: #kwin, zzag
Reviewed By: #kwin, zzag
Subscribers: zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D24215
2019-09-27 15:06:37 +00:00
|
|
|
void SceneOpenGL::paintEffectQuickView(EffectQuickView *w)
|
|
|
|
{
|
|
|
|
GLShader *shader = ShaderManager::instance()->pushShader(ShaderTrait::MapTexture);
|
|
|
|
const QRect rect = w->geometry();
|
|
|
|
|
|
|
|
GLTexture *t = w->bufferAsTexture();
|
|
|
|
if (!t) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
QMatrix4x4 mvp(projectionMatrix());
|
|
|
|
mvp.translate(rect.x(), rect.y());
|
|
|
|
shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
|
|
|
|
|
|
|
|
glEnable(GL_BLEND);
|
2019-10-02 19:51:47 +00:00
|
|
|
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
|
[libkwineffects] Introduce API to easily show a QtQuick scene in an effect
Summary:
EffectQuickView/Scene is a convenient class to render a QtQuick
scenegraph into an effect.
Current methods (such as present windows) involve creating an underlying
platform window which is expensive, causes a headache to filter out
again in the rest of the code, and only works as an overlay.
The new class exposes things more natively to an effect where we don't
mess with real windows, we can perform the painting anywhere in the view
and we don't have issues with hiding/closing.
QtQuick has both software and hardware accelerated modes, and kwin also
has 3 render backends. Every combination is supported.
* When used in OpenGL mode for both, we render into an FBO export the
texture ID then it's up to the effect to render that into a scene.
* When using software QtQuick rendering we blit into an image, upload
that into a KWinGLTexture which serves as an abstraction layer and
render that into the scene.
* When using GL for QtQuick and XRender/QPainter in kwin everything is
rendered into the internal FBO, blit and exported as an image.
* When using software rendering for both an image gets passed directly.
Mouse and keyboard events can be forwarded, only if the effect
intercepts them.
The class is meant to be generic enough that we can remove all the
QtQuick code from Aurorae.
The intention is also to replace EffectFrameImpl using this backend and
we can kill all of the EffectFrame code throughout the scenes.
The close button in present windows will also be ported to this,
simplifiying that code base.
Classes that handle the rendering and handling QML are intentionally
split so that in the future we can have a declarative effects API create
overlays from within the same context. Similar to how one can
instantiate windows from a typical QML scene.
Notes:
I don't like how I pass the kwin GL context from the backends into the
effect, but I need something that works with the library separation. It
also currently has wayland problem if I create a QOpenGLContext before
the QPA is set up with a scene - but I don't have anything better?
I know for the EffectFrame we need an API to push things through the
effects stack to handle blur/invert etc. Will deal with that when we
port the EffectFrame.
Test Plan: Used in an effect
Reviewers: #kwin, zzag
Reviewed By: #kwin, zzag
Subscribers: zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D24215
2019-09-27 15:06:37 +00:00
|
|
|
t->bind();
|
|
|
|
t->render(QRegion(infiniteRegion()), w->geometry());
|
|
|
|
t->unbind();
|
|
|
|
glDisable(GL_BLEND);
|
2019-10-02 19:31:38 +00:00
|
|
|
|
|
|
|
ShaderManager::instance()->popShader();
|
[libkwineffects] Introduce API to easily show a QtQuick scene in an effect
Summary:
EffectQuickView/Scene is a convenient class to render a QtQuick
scenegraph into an effect.
Current methods (such as present windows) involve creating an underlying
platform window which is expensive, causes a headache to filter out
again in the rest of the code, and only works as an overlay.
The new class exposes things more natively to an effect where we don't
mess with real windows, we can perform the painting anywhere in the view
and we don't have issues with hiding/closing.
QtQuick has both software and hardware accelerated modes, and kwin also
has 3 render backends. Every combination is supported.
* When used in OpenGL mode for both, we render into an FBO export the
texture ID then it's up to the effect to render that into a scene.
* When using software QtQuick rendering we blit into an image, upload
that into a KWinGLTexture which serves as an abstraction layer and
render that into the scene.
* When using GL for QtQuick and XRender/QPainter in kwin everything is
rendered into the internal FBO, blit and exported as an image.
* When using software rendering for both an image gets passed directly.
Mouse and keyboard events can be forwarded, only if the effect
intercepts them.
The class is meant to be generic enough that we can remove all the
QtQuick code from Aurorae.
The intention is also to replace EffectFrameImpl using this backend and
we can kill all of the EffectFrame code throughout the scenes.
The close button in present windows will also be ported to this,
simplifiying that code base.
Classes that handle the rendering and handling QML are intentionally
split so that in the future we can have a declarative effects API create
overlays from within the same context. Similar to how one can
instantiate windows from a typical QML scene.
Notes:
I don't like how I pass the kwin GL context from the backends into the
effect, but I need something that works with the library separation. It
also currently has wayland problem if I create a QOpenGLContext before
the QPA is set up with a scene - but I don't have anything better?
I know for the EffectFrame we need an API to push things through the
effects stack to handle blur/invert etc. Will deal with that when we
port the EffectFrame.
Test Plan: Used in an effect
Reviewers: #kwin, zzag
Reviewed By: #kwin, zzag
Subscribers: zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D24215
2019-09-27 15:06:37 +00:00
|
|
|
}
|
|
|
|
|
Better handling for making the compositing OpenGL context current
With QtQuick2 it's possible that the scene graph rendering context either
lives in an own thread or uses the main GUI thread. In the latter case
it's the same thread as our compositing OpenGL context lives in. This
means our basic assumption that between two rendering passes the context
stays current does not hold.
The code already ensured that before we start a rendering pass the
context is made current, but there are many more possible cases. If we
use OpenGL in areas not triggered by the rendering loop but in response
to other events the context needs to be made current. This includes the
loading and unloading of effects (some effects use OpenGL in the static
effect check, in the ctor and dtor), background loading of texture data,
lazy loading after first usage invoked by shortcut, etc. etc.
To properly handle these cases new methods are added to EffectsHandler
to make the compositing OpenGL context current. These calls delegate down
into the scene. On non-OpenGL scenes they are noop, but on OpenGL they go
into the backend and make the context current. In addition they ensure
that Qt doesn't think that it's QOpenGLContext is current by calling
doneCurrent() on the QOpenGLContext::currentContext(). This unfortunately
causes an additional call to makeCurrent with a null context, but there
is no other way to tell Qt - it doesn't notice when a different context
is made current with low level API calls. In the multi-threaded
architecture this doesn't matter as ::currentContext() returns null.
A short evaluation showed that a transition to QOpenGLContext doesn't
seem feasible. Qt only supports either GLX or EGL while KWin supports
both and when entering the transition phase for Wayland, it would become
extremely tricky if our native platform is X11, but we want a Wayland
EGL context. A future solution might be to have a "KWin-QPA plugin" which
uses either xcb or Wayland and hides everything from Qt.
The API documentation is extended to describe when the effects-framework
ensures that an OpenGL context is current. The effects are changed to
make the context current in cases where it's not guaranteed. This has
been done by looking for creation or deletion of GLTextures and Shaders.
If there are other OpenGL usages outside the rendering loop, ctor/dtor
this needs to be changed, too.
2013-11-22 14:05:36 +00:00
|
|
|
bool SceneOpenGL::makeOpenGLContextCurrent()
|
|
|
|
{
|
|
|
|
return m_backend->makeCurrent();
|
|
|
|
}
|
|
|
|
|
|
|
|
void SceneOpenGL::doneOpenGLContextCurrent()
|
|
|
|
{
|
|
|
|
m_backend->doneCurrent();
|
|
|
|
}
|
|
|
|
|
2020-10-12 06:45:05 +00:00
|
|
|
bool SceneOpenGL::supportsSurfacelessContext() const
|
|
|
|
{
|
|
|
|
return m_backend->supportsSurfacelessContext();
|
|
|
|
}
|
|
|
|
|
2020-10-15 09:27:00 +00:00
|
|
|
bool SceneOpenGL::supportsNativeFence() const
|
|
|
|
{
|
|
|
|
return m_backend->supportsNativeFence();
|
|
|
|
}
|
|
|
|
|
2013-06-24 06:49:24 +00:00
|
|
|
Scene::EffectFrame *SceneOpenGL::createEffectFrame(EffectFrameImpl *frame)
|
|
|
|
{
|
|
|
|
return new SceneOpenGL::EffectFrame(frame, this);
|
|
|
|
}
|
|
|
|
|
2013-06-24 07:06:50 +00:00
|
|
|
Shadow *SceneOpenGL::createShadow(Toplevel *toplevel)
|
|
|
|
{
|
|
|
|
return new SceneOpenGLShadow(toplevel);
|
|
|
|
}
|
|
|
|
|
2014-07-22 11:11:19 +00:00
|
|
|
Decoration::Renderer *SceneOpenGL::createDecorationRenderer(Decoration::DecoratedClientImpl *impl)
|
|
|
|
{
|
|
|
|
return new SceneOpenGLDecorationRenderer(impl);
|
|
|
|
}
|
|
|
|
|
2016-08-10 07:24:53 +00:00
|
|
|
bool SceneOpenGL::animationsSupported() const
|
|
|
|
{
|
|
|
|
return !GLPlatform::instance()->isSoftwareEmulation();
|
|
|
|
}
|
|
|
|
|
2017-09-08 13:49:52 +00:00
|
|
|
QVector<QByteArray> SceneOpenGL::openGLPlatformInterfaceExtensions() const
|
|
|
|
{
|
|
|
|
return m_backend->extensions().toVector();
|
|
|
|
}
|
|
|
|
|
2020-07-22 17:22:36 +00:00
|
|
|
QSharedPointer<GLTexture> SceneOpenGL::textureForOutput(AbstractOutput* output) const
|
|
|
|
{
|
|
|
|
return m_backend->textureForOutput(output);
|
|
|
|
}
|
|
|
|
|
2012-09-06 15:13:22 +00:00
|
|
|
//****************************************
|
|
|
|
// SceneOpenGL2
|
|
|
|
//****************************************
|
|
|
|
bool SceneOpenGL2::supported(OpenGLBackend *backend)
|
|
|
|
{
|
2012-10-05 16:00:49 +00:00
|
|
|
const QByteArray forceEnv = qgetenv("KWIN_COMPOSE");
|
|
|
|
if (!forceEnv.isEmpty()) {
|
2015-11-02 12:54:53 +00:00
|
|
|
if (qstrcmp(forceEnv, "O2") == 0 || qstrcmp(forceEnv, "O2ES") == 0) {
|
2017-09-08 20:30:18 +00:00
|
|
|
qCDebug(KWIN_OPENGL) << "OpenGL 2 compositing enforced by environment variable";
|
2012-10-05 16:00:49 +00:00
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
// OpenGL 2 disabled by environment variable
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2012-09-06 15:13:22 +00:00
|
|
|
if (!backend->isDirectRendering()) {
|
|
|
|
return false;
|
|
|
|
}
|
2012-10-05 16:00:49 +00:00
|
|
|
if (GLPlatform::instance()->recommendedCompositor() < OpenGL2Compositing) {
|
2017-09-08 20:30:18 +00:00
|
|
|
qCDebug(KWIN_OPENGL) << "Driver does not recommend OpenGL 2 compositing";
|
2012-09-06 15:13:22 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-02-23 13:41:45 +00:00
|
|
|
SceneOpenGL2::SceneOpenGL2(OpenGLBackend *backend, QObject *parent)
|
|
|
|
: SceneOpenGL(backend, parent)
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
, m_lanczosFilter(nullptr)
|
2012-09-06 15:13:22 +00:00
|
|
|
{
|
2012-11-22 14:08:48 +00:00
|
|
|
if (!init_ok) {
|
|
|
|
// base ctor already failed
|
|
|
|
return;
|
|
|
|
}
|
2014-11-22 13:19:05 +00:00
|
|
|
|
|
|
|
// We only support the OpenGL 2+ shader API, not GL_ARB_shader_objects
|
|
|
|
if (!hasGLVersion(2, 0)) {
|
2017-09-08 20:30:18 +00:00
|
|
|
qCDebug(KWIN_OPENGL) << "OpenGL 2.0 is not supported";
|
2014-11-22 13:19:05 +00:00
|
|
|
init_ok = false;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-11-25 07:40:23 +00:00
|
|
|
const QSize &s = screens()->size();
|
|
|
|
GLRenderTarget::setVirtualScreenSize(s);
|
2016-10-25 08:43:54 +00:00
|
|
|
GLRenderTarget::setVirtualScreenGeometry(screens()->geometry());
|
2012-09-06 15:13:22 +00:00
|
|
|
|
|
|
|
// push one shader on the stack so that one is always bound
|
2014-04-01 16:10:02 +00:00
|
|
|
ShaderManager::instance()->pushShader(ShaderTrait::MapTexture);
|
2012-09-06 15:13:22 +00:00
|
|
|
if (checkGLError("Init")) {
|
2017-09-08 20:30:18 +00:00
|
|
|
qCCritical(KWIN_OPENGL) << "OpenGL 2 compositing setup failed";
|
2012-11-22 14:08:48 +00:00
|
|
|
init_ok = false;
|
2012-09-06 15:13:22 +00:00
|
|
|
return; // error
|
|
|
|
}
|
2013-03-13 16:03:30 +00:00
|
|
|
|
|
|
|
// It is not legal to not have a vertex array object bound in a core context
|
2015-10-30 11:34:39 +00:00
|
|
|
if (!GLPlatform::instance()->isGLES() && hasGLExtension(QByteArrayLiteral("GL_ARB_vertex_array_object"))) {
|
2013-03-13 16:03:30 +00:00
|
|
|
glGenVertexArrays(1, &vao);
|
|
|
|
glBindVertexArray(vao);
|
|
|
|
}
|
|
|
|
|
2014-11-15 11:59:12 +00:00
|
|
|
if (!ShaderManager::instance()->selfTest()) {
|
2017-09-08 20:30:18 +00:00
|
|
|
qCCritical(KWIN_OPENGL) << "ShaderManager self test failed";
|
2014-11-15 11:59:12 +00:00
|
|
|
init_ok = false;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-09-08 20:30:18 +00:00
|
|
|
qCDebug(KWIN_OPENGL) << "OpenGL 2 compositing successfully initialized";
|
2013-03-13 16:03:30 +00:00
|
|
|
init_ok = true;
|
2012-09-06 15:13:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SceneOpenGL2::~SceneOpenGL2()
|
|
|
|
{
|
2019-01-18 18:39:49 +00:00
|
|
|
if (m_lanczosFilter) {
|
|
|
|
makeOpenGLContextCurrent();
|
|
|
|
delete m_lanczosFilter;
|
|
|
|
m_lanczosFilter = nullptr;
|
|
|
|
}
|
2012-09-06 15:13:22 +00:00
|
|
|
}
|
|
|
|
|
2014-04-01 16:08:27 +00:00
|
|
|
QMatrix4x4 SceneOpenGL2::createProjectionMatrix() const
|
|
|
|
{
|
|
|
|
// Create a perspective projection with a 60° field-of-view,
|
|
|
|
// and an aspect ratio of 1.0.
|
|
|
|
const float fovY = 60.0f;
|
|
|
|
const float aspect = 1.0f;
|
|
|
|
const float zNear = 0.1f;
|
|
|
|
const float zFar = 100.0f;
|
|
|
|
|
|
|
|
const float yMax = zNear * std::tan(fovY * M_PI / 360.0f);
|
|
|
|
const float yMin = -yMax;
|
|
|
|
const float xMin = yMin * aspect;
|
|
|
|
const float xMax = yMax * aspect;
|
|
|
|
|
|
|
|
QMatrix4x4 projection;
|
|
|
|
projection.frustum(xMin, xMax, yMin, yMax, zNear, zFar);
|
|
|
|
|
|
|
|
// Create a second matrix that transforms screen coordinates
|
|
|
|
// to world coordinates.
|
|
|
|
const float scaleFactor = 1.1 * std::tan(fovY * M_PI / 360.0f) / yMax;
|
|
|
|
const QSize size = screens()->size();
|
|
|
|
|
|
|
|
QMatrix4x4 matrix;
|
|
|
|
matrix.translate(xMin * scaleFactor, yMax * scaleFactor, -1.1);
|
|
|
|
matrix.scale( (xMax - xMin) * scaleFactor / size.width(),
|
|
|
|
-(yMax - yMin) * scaleFactor / size.height(),
|
|
|
|
0.001);
|
|
|
|
|
|
|
|
// Combine the matrices
|
|
|
|
return projection * matrix;
|
|
|
|
}
|
|
|
|
|
2015-11-26 13:48:57 +00:00
|
|
|
void SceneOpenGL2::updateProjectionMatrix()
|
2014-04-01 16:08:27 +00:00
|
|
|
{
|
|
|
|
m_projectionMatrix = createProjectionMatrix();
|
2015-11-26 13:48:57 +00:00
|
|
|
}
|
|
|
|
|
2020-03-13 16:41:56 +00:00
|
|
|
void SceneOpenGL2::paintSimpleScreen(int mask, const QRegion ®ion)
|
2015-11-26 13:48:57 +00:00
|
|
|
{
|
2014-04-01 16:08:27 +00:00
|
|
|
m_screenProjectionMatrix = m_projectionMatrix;
|
|
|
|
|
|
|
|
Scene::paintSimpleScreen(mask, region);
|
|
|
|
}
|
|
|
|
|
2020-03-13 16:41:56 +00:00
|
|
|
void SceneOpenGL2::paintGenericScreen(int mask, const ScreenPaintData &data)
|
2012-09-06 15:13:22 +00:00
|
|
|
{
|
2014-04-01 16:08:27 +00:00
|
|
|
const QMatrix4x4 screenMatrix = transformation(mask, data);
|
|
|
|
|
2015-11-26 13:48:57 +00:00
|
|
|
m_screenProjectionMatrix = m_projectionMatrix * screenMatrix;
|
2012-09-06 15:13:22 +00:00
|
|
|
|
|
|
|
Scene::paintGenericScreen(mask, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SceneOpenGL2::doPaintBackground(const QVector< float >& vertices)
|
|
|
|
{
|
|
|
|
GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
|
|
|
|
vbo->reset();
|
|
|
|
vbo->setUseColor(true);
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
vbo->setData(vertices.count() / 2, 2, vertices.data(), nullptr);
|
2012-09-06 15:13:22 +00:00
|
|
|
|
2015-11-26 08:37:23 +00:00
|
|
|
ShaderBinder binder(ShaderTrait::UniformColor);
|
|
|
|
binder.shader()->setUniform(GLShader::ModelViewProjectionMatrix, m_projectionMatrix);
|
2012-09-06 15:13:22 +00:00
|
|
|
|
|
|
|
vbo->render(GL_TRIANGLES);
|
|
|
|
}
|
|
|
|
|
2013-06-24 07:53:11 +00:00
|
|
|
Scene::Window *SceneOpenGL2::createWindow(Toplevel *t)
|
2012-09-06 15:13:22 +00:00
|
|
|
{
|
2020-01-15 21:18:28 +00:00
|
|
|
return new OpenGLWindow(t, this);
|
2012-09-06 15:13:22 +00:00
|
|
|
}
|
|
|
|
|
2020-03-13 16:41:56 +00:00
|
|
|
void SceneOpenGL2::finalDrawWindow(EffectWindowImpl* w, int mask, const QRegion ®ion, WindowPaintData& data)
|
2012-11-13 20:41:02 +00:00
|
|
|
{
|
2015-12-04 15:37:54 +00:00
|
|
|
if (waylandServer() && waylandServer()->isScreenLocked() && !w->window()->isLockScreen() && !w->window()->isInputMethod()) {
|
2015-11-23 10:33:49 +00:00
|
|
|
return;
|
|
|
|
}
|
Drop OpenGL based color correction from KWin
Summary:
The feature has always been considered experimental. Unfortunately it is
completely unmaintained and hasn't seen any commits in years. It
requires kolor-manager to function, but that has not seen a release
based on frameworks yet. This makes it difficult to maintain. In fact I
have never been able from the introduction till now to setup a color
corrected system. One needs kolor-manager and oyranos and especially the
latter is hardly available on any linux distribution (e.g. not on the
Debian/Ubuntu systems).
Due to being unmaintained color correction in KWin did not keep up with
recent changes. Neither did it see any updates during the xlib->xcb
port, nor during the Wayland port. Especially the Wayland port with the
rendering changes make it unlikely to function correctly. E.g. Wayland
introduced a proper per-screen rendering, while color correction did a
"fake" per screen rendering. How that is going to work in combination is
something nobody ever tried. Now after the introduction of proper
per-screen rendering the solution would be to port color correction to
the new api, but that never happened.
Color correction also modified the shaders, but a newer shader API got
introduced some time ago. Whether the color correction shader support
that or not, is unknown to me. Also which shader language versions are
supported. I know it was based on 3d texture support, which back on
introduction was partially lacking in OpenGL ES. Nowadays that changed,
but color correction didn't update.
Last but not least it is completely X11 based and there is no work on
how to make it work with Wayland.
Given all the problems, especially the fact that it is unmaintained and
cannot be setup on my system, means to me that the only solution is to
remove it.
I'm open to having it reintroduced in future, but only if the
availability on Linux distributions gets addressed before. As long as
major linux distributions do not ship this feature, it should not be in
KWin. Given that I must say that it was a mistake to add it in the first
place and I need to point out that I was against the merge back then.
Reviewers: #kwin, #plasma
Subscribers: plasma-devel, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D3402
2016-11-17 14:03:54 +00:00
|
|
|
performPaintWindow(w, mask, region, data);
|
2012-11-13 20:41:02 +00:00
|
|
|
}
|
|
|
|
|
2020-03-13 16:41:56 +00:00
|
|
|
void SceneOpenGL2::performPaintWindow(EffectWindowImpl* w, int mask, const QRegion ®ion, WindowPaintData& data)
|
2012-11-13 20:41:02 +00:00
|
|
|
{
|
|
|
|
if (mask & PAINT_WINDOW_LANCZOS) {
|
2013-02-08 11:12:51 +00:00
|
|
|
if (!m_lanczosFilter) {
|
2012-11-13 20:41:02 +00:00
|
|
|
m_lanczosFilter = new LanczosFilter(this);
|
2017-09-20 16:46:27 +00:00
|
|
|
// reset the lanczos filter when the screen gets resized
|
|
|
|
// it will get created next paint
|
|
|
|
connect(screens(), &Screens::changed, this, [this]() {
|
|
|
|
makeOpenGLContextCurrent();
|
|
|
|
delete m_lanczosFilter;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_lanczosFilter = nullptr;
|
2017-09-20 16:46:27 +00:00
|
|
|
});
|
2012-11-13 20:41:02 +00:00
|
|
|
}
|
2013-02-08 11:12:51 +00:00
|
|
|
m_lanczosFilter->performPaint(w, mask, region, data);
|
2012-11-13 20:41:02 +00:00
|
|
|
} else
|
|
|
|
w->sceneWindow()->performPaint(mask, region, data);
|
|
|
|
}
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
//****************************************
|
2020-01-15 21:18:28 +00:00
|
|
|
// OpenGLWindow
|
2007-04-29 17:35:43 +00:00
|
|
|
//****************************************
|
|
|
|
|
2020-01-15 21:18:28 +00:00
|
|
|
OpenGLWindow::OpenGLWindow(Toplevel *toplevel, SceneOpenGL *scene)
|
|
|
|
: Scene::Window(toplevel)
|
|
|
|
, m_scene(scene)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2020-01-15 21:18:28 +00:00
|
|
|
OpenGLWindow::~OpenGLWindow()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
// Bind the window pixmap to an OpenGL texture.
|
2020-01-15 21:18:28 +00:00
|
|
|
bool OpenGLWindow::bindTexture()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2013-05-10 10:07:56 +00:00
|
|
|
OpenGLWindowPixmap *pixmap = windowPixmap<OpenGLWindowPixmap>();
|
|
|
|
if (!pixmap) {
|
|
|
|
return false;
|
2012-08-26 15:14:23 +00:00
|
|
|
}
|
2013-05-10 10:07:56 +00:00
|
|
|
if (pixmap->isDiscarded()) {
|
|
|
|
return !pixmap->texture()->isNull();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2014-09-03 16:43:38 +00:00
|
|
|
|
|
|
|
if (!window()->damage().isEmpty())
|
|
|
|
m_scene->insertWait();
|
|
|
|
|
2013-05-10 10:07:56 +00:00
|
|
|
return pixmap->bind();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-07-05 19:59:55 +00:00
|
|
|
|
2020-01-15 21:18:28 +00:00
|
|
|
QMatrix4x4 OpenGLWindow::transformation(int mask, const WindowPaintData &data) const
|
2011-02-15 17:10:54 +00:00
|
|
|
{
|
|
|
|
QMatrix4x4 matrix;
|
|
|
|
matrix.translate(x(), y());
|
|
|
|
|
2020-01-15 21:18:28 +00:00
|
|
|
if (!(mask & Scene::PAINT_WINDOW_TRANSFORMED))
|
2011-02-15 17:10:54 +00:00
|
|
|
return matrix;
|
|
|
|
|
2012-05-28 12:45:46 +00:00
|
|
|
matrix.translate(data.translation());
|
2020-10-30 20:47:41 +00:00
|
|
|
const QVector3D scale = data.scale();
|
|
|
|
matrix.scale(scale.x(), scale.y(), scale.z());
|
2011-02-15 17:10:54 +00:00
|
|
|
|
2012-06-02 19:54:18 +00:00
|
|
|
if (data.rotationAngle() == 0.0)
|
2011-02-15 17:10:54 +00:00
|
|
|
return matrix;
|
|
|
|
|
|
|
|
// Apply the rotation
|
2012-05-27 17:28:02 +00:00
|
|
|
// cannot use data.rotation.applyTo(&matrix) as QGraphicsRotation uses projectedRotate to map back to 2D
|
2012-06-02 19:54:18 +00:00
|
|
|
matrix.translate(data.rotationOrigin());
|
|
|
|
const QVector3D axis = data.rotationAxis();
|
|
|
|
matrix.rotate(data.rotationAngle(), axis.x(), axis.y(), axis.z());
|
|
|
|
matrix.translate(-data.rotationOrigin());
|
2011-02-15 17:10:54 +00:00
|
|
|
|
|
|
|
return matrix;
|
|
|
|
}
|
|
|
|
|
2020-01-15 21:18:28 +00:00
|
|
|
bool OpenGLWindow::beginRenderWindow(int mask, const QRegion ®ion, WindowPaintData &data)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
|
|
|
if (region.isEmpty())
|
2013-03-17 12:34:26 +00:00
|
|
|
return false;
|
2011-02-15 21:34:23 +00:00
|
|
|
|
2020-01-15 21:18:28 +00:00
|
|
|
m_hardwareClipping = region != infiniteRegion() && (mask & Scene::PAINT_WINDOW_TRANSFORMED) && !(mask & Scene::PAINT_SCREEN_TRANSFORMED);
|
2013-03-17 10:50:47 +00:00
|
|
|
if (region != infiniteRegion() && !m_hardwareClipping) {
|
2011-06-26 10:01:13 +00:00
|
|
|
WindowQuadList quads;
|
2013-06-11 19:16:09 +00:00
|
|
|
quads.reserve(data.quads.count());
|
|
|
|
|
2011-06-26 10:01:13 +00:00
|
|
|
const QRegion filterRegion = region.translated(-x(), -y());
|
2011-06-26 11:16:14 +00:00
|
|
|
// split all quads in bounding rect with the actual rects in the region
|
2020-09-17 01:12:37 +00:00
|
|
|
for (const WindowQuad &quad : qAsConst(data.quads)) {
|
2017-12-02 09:05:04 +00:00
|
|
|
for (const QRect &r : filterRegion) {
|
2011-06-26 11:16:14 +00:00
|
|
|
const QRectF rf(r);
|
|
|
|
const QRectF quadRect(QPointF(quad.left(), quad.top()), QPointF(quad.right(), quad.bottom()));
|
2013-11-28 12:19:48 +00:00
|
|
|
const QRectF &intersected = rf.intersected(quadRect);
|
|
|
|
if (intersected.isValid()) {
|
|
|
|
if (quadRect == intersected) {
|
|
|
|
// case 1: completely contains, include and do not check other rects
|
|
|
|
quads << quad;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// case 2: intersection
|
2011-06-26 11:16:14 +00:00
|
|
|
quads << quad.makeSubQuad(intersected.left(), intersected.top(), intersected.right(), intersected.bottom());
|
2011-06-26 10:01:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-06-26 11:16:14 +00:00
|
|
|
data.quads = quads;
|
2011-06-26 10:01:13 +00:00
|
|
|
}
|
|
|
|
|
2013-06-07 21:46:06 +00:00
|
|
|
if (data.quads.isEmpty())
|
|
|
|
return false;
|
|
|
|
|
2020-04-21 10:22:41 +00:00
|
|
|
if (!bindTexture()) {
|
2013-03-17 12:34:26 +00:00
|
|
|
return false;
|
2012-02-12 15:42:09 +00:00
|
|
|
}
|
|
|
|
|
2013-03-17 10:50:47 +00:00
|
|
|
if (m_hardwareClipping) {
|
2012-02-12 15:42:09 +00:00
|
|
|
glEnable(GL_SCISSOR_TEST);
|
|
|
|
}
|
2011-02-15 16:47:31 +00:00
|
|
|
|
2012-10-12 11:20:23 +00:00
|
|
|
const GLVertexAttrib attribs[] = {
|
|
|
|
{ VA_Position, 2, GL_FLOAT, offsetof(GLVertex2D, position) },
|
|
|
|
{ VA_TexCoord, 2, GL_FLOAT, offsetof(GLVertex2D, texcoord) },
|
|
|
|
};
|
|
|
|
|
2010-12-11 15:11:19 +00:00
|
|
|
GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
|
|
|
|
vbo->reset();
|
2012-10-12 11:20:23 +00:00
|
|
|
vbo->setAttribLayout(attribs, 2, sizeof(GLVertex2D));
|
2009-04-22 17:30:49 +00:00
|
|
|
|
2013-03-17 12:34:26 +00:00
|
|
|
return true;
|
|
|
|
}
|
2009-11-25 23:08:19 +00:00
|
|
|
|
2020-01-15 21:18:28 +00:00
|
|
|
void OpenGLWindow::endRenderWindow()
|
2013-03-17 12:34:26 +00:00
|
|
|
{
|
2013-03-17 10:50:47 +00:00
|
|
|
if (m_hardwareClipping) {
|
2012-02-12 15:42:09 +00:00
|
|
|
glDisable(GL_SCISSOR_TEST);
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-04-22 17:30:49 +00:00
|
|
|
|
2020-01-15 21:18:28 +00:00
|
|
|
GLTexture *OpenGLWindow::getDecorationTexture() const
|
2013-03-17 11:16:08 +00:00
|
|
|
{
|
2015-12-03 16:41:06 +00:00
|
|
|
if (AbstractClient *client = dynamic_cast<AbstractClient *>(toplevel)) {
|
2014-10-21 05:46:44 +00:00
|
|
|
if (!client->isDecorated()) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
if (SceneOpenGLDecorationRenderer *renderer = static_cast<SceneOpenGLDecorationRenderer*>(client->decoratedClient()->renderer())) {
|
|
|
|
renderer->render();
|
|
|
|
return renderer->texture();
|
2014-07-22 11:11:19 +00:00
|
|
|
}
|
2014-07-23 07:20:28 +00:00
|
|
|
} else if (toplevel->isDeleted()) {
|
2013-03-17 11:16:08 +00:00
|
|
|
Deleted *deleted = static_cast<Deleted *>(toplevel);
|
2020-11-04 07:22:32 +00:00
|
|
|
if (!deleted->wasDecorated()) {
|
2014-07-23 07:20:28 +00:00
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
if (const SceneOpenGLDecorationRenderer *renderer = static_cast<const SceneOpenGLDecorationRenderer*>(deleted->decorationRenderer())) {
|
|
|
|
return renderer->texture();
|
|
|
|
}
|
2013-03-17 11:16:08 +00:00
|
|
|
}
|
2014-07-22 11:11:19 +00:00
|
|
|
return nullptr;
|
2013-03-17 11:16:08 +00:00
|
|
|
}
|
|
|
|
|
2020-01-15 21:18:28 +00:00
|
|
|
WindowPixmap *OpenGLWindow::createWindowPixmap()
|
2013-05-10 10:07:56 +00:00
|
|
|
{
|
|
|
|
return new OpenGLWindowPixmap(this, m_scene);
|
|
|
|
}
|
2012-09-06 10:25:55 +00:00
|
|
|
|
2020-01-15 21:18:28 +00:00
|
|
|
QVector4D OpenGLWindow::modulate(float opacity, float brightness) const
|
2012-09-06 10:25:55 +00:00
|
|
|
{
|
2013-03-17 12:34:26 +00:00
|
|
|
const float a = opacity;
|
|
|
|
const float rgb = opacity * brightness;
|
|
|
|
|
|
|
|
return QVector4D(rgb, rgb, rgb, a);
|
|
|
|
}
|
|
|
|
|
2020-01-15 21:18:28 +00:00
|
|
|
void OpenGLWindow::setBlendEnabled(bool enabled)
|
2013-03-17 12:34:26 +00:00
|
|
|
{
|
|
|
|
if (enabled && !m_blendingEnabled)
|
|
|
|
glEnable(GL_BLEND);
|
|
|
|
else if (!enabled && m_blendingEnabled)
|
|
|
|
glDisable(GL_BLEND);
|
|
|
|
|
|
|
|
m_blendingEnabled = enabled;
|
|
|
|
}
|
|
|
|
|
2020-04-21 10:22:41 +00:00
|
|
|
/**
|
|
|
|
* \internal
|
|
|
|
*
|
|
|
|
* Counts the total number of pixmaps in the tree with the given root \a windowPixmap.
|
|
|
|
*/
|
|
|
|
static int windowPixmapCount(WindowPixmap *windowPixmap)
|
|
|
|
{
|
|
|
|
int count = 1; // 1 for the window pixmap itself.
|
|
|
|
|
|
|
|
const QVector<WindowPixmap *> children = windowPixmap->children();
|
|
|
|
for (WindowPixmap *child : children)
|
|
|
|
count += windowPixmapCount(child);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
void OpenGLWindow::initializeRenderContext(RenderContext &context, const WindowPaintData &data)
|
2013-03-18 15:45:53 +00:00
|
|
|
{
|
2020-04-21 10:22:41 +00:00
|
|
|
WindowPixmap *currentPixmap = windowPixmap<OpenGLWindowPixmap>();
|
|
|
|
|
|
|
|
context.shadowOffset = 0;
|
|
|
|
context.decorationOffset = 1;
|
|
|
|
context.contentOffset = 2;
|
|
|
|
context.previousContentOffset = windowPixmapCount(currentPixmap) + 2;
|
|
|
|
context.quadCount = data.quads.count();
|
|
|
|
|
|
|
|
const int nodeCount = context.previousContentOffset + 1;
|
|
|
|
|
|
|
|
QVector<RenderNode> &renderNodes = context.renderNodes;
|
|
|
|
renderNodes.resize(nodeCount);
|
|
|
|
|
|
|
|
for (const WindowQuad &quad : data.quads) {
|
|
|
|
switch (quad.type()) {
|
|
|
|
case WindowQuadShadow:
|
|
|
|
renderNodes[context.shadowOffset].quads << quad;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WindowQuadDecoration:
|
|
|
|
renderNodes[context.decorationOffset].quads << quad;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WindowQuadContents:
|
|
|
|
renderNodes[context.contentOffset + quad.id()].quads << quad;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
// Ignore window quad generated by effects.
|
|
|
|
break;
|
|
|
|
}
|
2013-03-18 15:45:53 +00:00
|
|
|
}
|
|
|
|
|
2020-04-21 10:22:41 +00:00
|
|
|
RenderNode &shadowRenderNode = renderNodes[context.shadowOffset];
|
|
|
|
if (!shadowRenderNode.quads.isEmpty()) {
|
|
|
|
SceneOpenGLShadow *shadow = static_cast<SceneOpenGLShadow *>(m_shadow);
|
|
|
|
shadowRenderNode.texture = shadow->shadowTexture();
|
|
|
|
shadowRenderNode.opacity = data.opacity();
|
|
|
|
shadowRenderNode.hasAlpha = true;
|
|
|
|
shadowRenderNode.coordinateType = NormalizedCoordinates;
|
|
|
|
shadowRenderNode.leafType = ShadowLeaf;
|
2013-03-18 15:45:53 +00:00
|
|
|
}
|
|
|
|
|
2020-04-21 10:22:41 +00:00
|
|
|
RenderNode &decorationRenderNode = renderNodes[context.decorationOffset];
|
|
|
|
if (!decorationRenderNode.quads.isEmpty()) {
|
|
|
|
decorationRenderNode.texture = getDecorationTexture();
|
|
|
|
decorationRenderNode.opacity = data.opacity();
|
|
|
|
decorationRenderNode.hasAlpha = true;
|
|
|
|
decorationRenderNode.coordinateType = UnnormalizedCoordinates;
|
|
|
|
decorationRenderNode.leafType = DecorationLeaf;
|
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: Cross-fading must be implemented in a shader.
|
|
|
|
float contentOpacity = data.opacity();
|
2013-08-05 13:12:08 +00:00
|
|
|
if (data.crossFadeProgress() != 1.0 && (data.opacity() < 0.95 || toplevel->hasAlpha())) {
|
|
|
|
const float opacity = 1.0 - data.crossFadeProgress();
|
2020-04-21 10:22:41 +00:00
|
|
|
contentOpacity *= 1 - pow(opacity, 1.0f + 2.0f * data.opacity());
|
|
|
|
}
|
|
|
|
|
|
|
|
// The main surface and all of its sub-surfaces form a tree. In order to initialize
|
|
|
|
// the render nodes for the window pixmaps we need to traverse the tree in the
|
|
|
|
// depth-first search manner. The id of content window quads corresponds to the time
|
|
|
|
// when we visited the corresponding window pixmap. The DFS traversal probably doesn't
|
|
|
|
// have a significant impact on performance. However, if that's the case, we could
|
|
|
|
// keep a cache of window pixmaps in the order in which they'll be rendered.
|
|
|
|
QStack<WindowPixmap *> stack;
|
|
|
|
stack.push(currentPixmap);
|
|
|
|
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
while (!stack.isEmpty()) {
|
|
|
|
OpenGLWindowPixmap *windowPixmap = static_cast<OpenGLWindowPixmap *>(stack.pop());
|
|
|
|
|
|
|
|
// If it's an unmapped sub-surface, don't render it and all of its children.
|
|
|
|
if (!windowPixmap->isValid())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
RenderNode &contentRenderNode = renderNodes[context.contentOffset + i++];
|
|
|
|
contentRenderNode.texture = windowPixmap->texture();
|
|
|
|
contentRenderNode.hasAlpha = windowPixmap->hasAlphaChannel();
|
|
|
|
contentRenderNode.opacity = contentOpacity;
|
|
|
|
contentRenderNode.coordinateType = UnnormalizedCoordinates;
|
|
|
|
contentRenderNode.leafType = ContentLeaf;
|
|
|
|
|
|
|
|
const QVector<WindowPixmap *> children = windowPixmap->children();
|
2020-12-13 15:46:22 +00:00
|
|
|
for (auto it = children.rbegin(); it != children.rend(); ++it) {
|
|
|
|
stack.push(*it);
|
|
|
|
}
|
2013-08-05 13:12:08 +00:00
|
|
|
}
|
2013-05-13 06:17:28 +00:00
|
|
|
|
2020-04-21 10:22:41 +00:00
|
|
|
// Note that cross-fading is currently working properly only on X11. In order to make it
|
|
|
|
// work on Wayland, we have to render the current and the previous window pixmap trees in
|
|
|
|
// offscreen render targets, then use a cross-fading shader to blend those two layers.
|
2013-05-13 06:17:28 +00:00
|
|
|
if (data.crossFadeProgress() != 1.0) {
|
|
|
|
OpenGLWindowPixmap *previous = previousWindowPixmap<OpenGLWindowPixmap>();
|
2020-04-21 10:22:41 +00:00
|
|
|
if (previous) { // TODO(vlad): Should cross-fading be disabled on Wayland?
|
|
|
|
const QRect &oldGeometry = previous->contentsRect();
|
|
|
|
RenderNode &previousContentRenderNode = renderNodes[context.previousContentOffset];
|
|
|
|
for (const WindowQuad &quad : qAsConst(renderNodes[context.contentOffset].quads)) {
|
|
|
|
// We need to create new window quads with normalized texture coordinates.
|
|
|
|
// Normal quads divide the x/y position by width/height. This would not work
|
|
|
|
// as the texture is larger than the visible content in case of a decorated
|
|
|
|
// Client resulting in garbage being shown. So we calculate the normalized
|
|
|
|
// texture coordinate in the Client's new content space and map it to the
|
|
|
|
// previous Client's content space.
|
|
|
|
WindowQuad newQuad(WindowQuadContents);
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
|
|
const qreal xFactor = (quad[i].textureX() - toplevel->clientPos().x())
|
|
|
|
/ qreal(toplevel->clientSize().width());
|
|
|
|
const qreal yFactor = (quad[i].textureY() - toplevel->clientPos().y())
|
|
|
|
/ qreal(toplevel->clientSize().height());
|
|
|
|
const qreal u = (xFactor * oldGeometry.width() + oldGeometry.x())
|
|
|
|
/ qreal(previous->size().width());
|
|
|
|
const qreal v = (yFactor * oldGeometry.height() + oldGeometry.y())
|
|
|
|
/ qreal(previous->size().height());
|
|
|
|
newQuad[i] = WindowVertex(quad[i].x(), quad[i].y(), u, v);
|
|
|
|
}
|
|
|
|
previousContentRenderNode.quads.append(newQuad);
|
|
|
|
}
|
|
|
|
|
|
|
|
previousContentRenderNode.texture = previous->texture();
|
|
|
|
previousContentRenderNode.hasAlpha = previous->hasAlphaChannel();
|
|
|
|
previousContentRenderNode.opacity = data.opacity() * (1.0 - data.crossFadeProgress());
|
|
|
|
previousContentRenderNode.coordinateType = NormalizedCoordinates;
|
|
|
|
previousContentRenderNode.leafType = PreviousContentLeaf;
|
|
|
|
|
|
|
|
context.quadCount += previousContentRenderNode.quads.count();
|
|
|
|
}
|
2013-05-13 06:17:28 +00:00
|
|
|
}
|
2013-03-18 15:45:53 +00:00
|
|
|
}
|
|
|
|
|
2020-01-15 21:18:28 +00:00
|
|
|
QMatrix4x4 OpenGLWindow::modelViewProjectionMatrix(int mask, const WindowPaintData &data) const
|
2014-04-01 16:08:48 +00:00
|
|
|
{
|
|
|
|
SceneOpenGL2 *scene = static_cast<SceneOpenGL2 *>(m_scene);
|
|
|
|
|
|
|
|
const QMatrix4x4 pMatrix = data.projectionMatrix();
|
|
|
|
const QMatrix4x4 mvMatrix = data.modelViewMatrix();
|
|
|
|
|
|
|
|
// An effect may want to override the default projection matrix in some cases,
|
|
|
|
// such as when it is rendering a window on a render target that doesn't have
|
|
|
|
// the same dimensions as the default framebuffer.
|
|
|
|
//
|
|
|
|
// Note that the screen transformation is not applied here.
|
|
|
|
if (!pMatrix.isIdentity())
|
|
|
|
return pMatrix * mvMatrix;
|
|
|
|
|
|
|
|
// If an effect has specified a model-view matrix, we multiply that matrix
|
|
|
|
// with the default projection matrix. If the effect hasn't specified a
|
|
|
|
// model-view matrix, mvMatrix will be the identity matrix.
|
|
|
|
if (mask & Scene::PAINT_SCREEN_TRANSFORMED)
|
|
|
|
return scene->screenProjectionMatrix() * mvMatrix;
|
|
|
|
|
|
|
|
return scene->projectionMatrix() * mvMatrix;
|
|
|
|
}
|
|
|
|
|
2020-03-13 16:41:56 +00:00
|
|
|
void OpenGLWindow::performPaint(int mask, const QRegion ®ion, const WindowPaintData &_data)
|
2013-03-17 12:34:26 +00:00
|
|
|
{
|
2020-03-13 16:41:56 +00:00
|
|
|
WindowPaintData data = _data;
|
2013-03-17 12:34:26 +00:00
|
|
|
if (!beginRenderWindow(mask, region, data))
|
|
|
|
return;
|
|
|
|
|
2016-03-31 13:00:48 +00:00
|
|
|
QMatrix4x4 windowMatrix = transformation(mask, data);
|
|
|
|
const QMatrix4x4 modelViewProjection = modelViewProjectionMatrix(mask, data);
|
|
|
|
const QMatrix4x4 mvpMatrix = modelViewProjection * windowMatrix;
|
2014-04-01 16:08:27 +00:00
|
|
|
|
Avoid texture bleed rendering X11 window
Summary:
We currently see a gap on transformed windows between the window and the
top decoration.
This is partly the atlas bleed on the decoration, and partly a bleed on
the window content itself.
On X11, the window we composite is the frame window - which is a larger
texture containing a transparent border where the frame normally would
be. When we sample with a linear filter we include these texels. Hence
GL_CLAMP_TO_EDGE doesn't work.
Vlad's patch to composite the correct window, not the frame was my
preferred approach, but we had to revert it as it caused an issue with
xwayland :(
Half pixel correction nearly worked, but caused blurry fonts.
This patch resolves it in the fragment shader used by effects doing
transforms. We pass the real texture geometry of the window to the
client with a half pixel correction. Any samples outside the outer half
pixel are then clamped within bounds.
Arguably a hack, but solves the problem in a comparatively
non-invasive way.
BUG: 360549
BUG: 257566
Test Plan:
X11:
Using Vlad's atlas padding for decoration
Slowed animations, wobbled a dark window over a light background
No artifacts
Wayland:
This isn't needed. Now tested that everything still renders the same.
Reviewers: #kwin, zzag
Reviewed By: #kwin, zzag
Subscribers: zzag, jgrulich, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D25737
2020-01-09 13:02:33 +00:00
|
|
|
bool useX11TextureClamp = false;
|
|
|
|
|
2012-09-06 10:25:55 +00:00
|
|
|
GLShader *shader = data.shader;
|
Avoid texture bleed rendering X11 window
Summary:
We currently see a gap on transformed windows between the window and the
top decoration.
This is partly the atlas bleed on the decoration, and partly a bleed on
the window content itself.
On X11, the window we composite is the frame window - which is a larger
texture containing a transparent border where the frame normally would
be. When we sample with a linear filter we include these texels. Hence
GL_CLAMP_TO_EDGE doesn't work.
Vlad's patch to composite the correct window, not the frame was my
preferred approach, but we had to revert it as it caused an issue with
xwayland :(
Half pixel correction nearly worked, but caused blurry fonts.
This patch resolves it in the fragment shader used by effects doing
transforms. We pass the real texture geometry of the window to the
client with a half pixel correction. Any samples outside the outer half
pixel are then clamped within bounds.
Arguably a hack, but solves the problem in a comparatively
non-invasive way.
BUG: 360549
BUG: 257566
Test Plan:
X11:
Using Vlad's atlas padding for decoration
Slowed animations, wobbled a dark window over a light background
No artifacts
Wayland:
This isn't needed. Now tested that everything still renders the same.
Reviewers: #kwin, zzag
Reviewed By: #kwin, zzag
Subscribers: zzag, jgrulich, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D25737
2020-01-09 13:02:33 +00:00
|
|
|
GLenum filter;
|
|
|
|
|
|
|
|
if (waylandServer()) {
|
|
|
|
filter = GL_LINEAR;
|
|
|
|
} else {
|
|
|
|
const bool isTransformed = mask & (Effect::PAINT_WINDOW_TRANSFORMED |
|
|
|
|
Effect::PAINT_SCREEN_TRANSFORMED);
|
|
|
|
useX11TextureClamp = isTransformed;
|
|
|
|
if (isTransformed && options->glSmoothScale() != 0) {
|
|
|
|
filter = GL_LINEAR;
|
|
|
|
} else {
|
|
|
|
filter = GL_NEAREST;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-06 10:25:55 +00:00
|
|
|
if (!shader) {
|
2014-04-01 16:08:27 +00:00
|
|
|
ShaderTraits traits = ShaderTrait::MapTexture;
|
Avoid texture bleed rendering X11 window
Summary:
We currently see a gap on transformed windows between the window and the
top decoration.
This is partly the atlas bleed on the decoration, and partly a bleed on
the window content itself.
On X11, the window we composite is the frame window - which is a larger
texture containing a transparent border where the frame normally would
be. When we sample with a linear filter we include these texels. Hence
GL_CLAMP_TO_EDGE doesn't work.
Vlad's patch to composite the correct window, not the frame was my
preferred approach, but we had to revert it as it caused an issue with
xwayland :(
Half pixel correction nearly worked, but caused blurry fonts.
This patch resolves it in the fragment shader used by effects doing
transforms. We pass the real texture geometry of the window to the
client with a half pixel correction. Any samples outside the outer half
pixel are then clamped within bounds.
Arguably a hack, but solves the problem in a comparatively
non-invasive way.
BUG: 360549
BUG: 257566
Test Plan:
X11:
Using Vlad's atlas padding for decoration
Slowed animations, wobbled a dark window over a light background
No artifacts
Wayland:
This isn't needed. Now tested that everything still renders the same.
Reviewers: #kwin, zzag
Reviewed By: #kwin, zzag
Subscribers: zzag, jgrulich, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D25737
2020-01-09 13:02:33 +00:00
|
|
|
if (useX11TextureClamp) {
|
|
|
|
traits |= ShaderTrait::ClampTexture;
|
|
|
|
}
|
2014-04-01 16:08:27 +00:00
|
|
|
|
2014-12-10 18:38:23 +00:00
|
|
|
if (data.opacity() != 1.0 || data.brightness() != 1.0 || data.crossFadeProgress() != 1.0)
|
2014-04-01 16:08:27 +00:00
|
|
|
traits |= ShaderTrait::Modulate;
|
|
|
|
|
|
|
|
if (data.saturation() != 1.0)
|
|
|
|
traits |= ShaderTrait::AdjustSaturation;
|
|
|
|
|
|
|
|
shader = ShaderManager::instance()->pushShader(traits);
|
2011-03-27 10:33:07 +00:00
|
|
|
}
|
2015-11-27 15:31:04 +00:00
|
|
|
shader->setUniform(GLShader::ModelViewProjectionMatrix, mvpMatrix);
|
2012-09-06 10:25:55 +00:00
|
|
|
|
2013-03-17 12:34:26 +00:00
|
|
|
shader->setUniform(GLShader::Saturation, data.saturation());
|
2011-03-27 10:33:07 +00:00
|
|
|
|
2020-04-21 10:22:41 +00:00
|
|
|
RenderContext renderContext;
|
|
|
|
initializeRenderContext(renderContext, data);
|
2013-05-13 06:17:28 +00:00
|
|
|
|
2013-03-21 22:52:03 +00:00
|
|
|
const bool indexedQuads = GLVertexBuffer::supportsIndexedQuads();
|
2014-07-22 10:26:38 +00:00
|
|
|
const GLenum primitiveType = indexedQuads ? GL_QUADS : GL_TRIANGLES;
|
2013-03-21 22:52:03 +00:00
|
|
|
const int verticesPerQuad = indexedQuads ? 4 : 6;
|
|
|
|
|
2020-04-21 10:22:41 +00:00
|
|
|
const size_t size = verticesPerQuad * renderContext.quadCount * sizeof(GLVertex2D);
|
2013-03-17 12:34:26 +00:00
|
|
|
|
2013-03-18 15:45:53 +00:00
|
|
|
GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
|
|
|
|
GLVertex2D *map = (GLVertex2D *) vbo->map(size);
|
2013-03-17 12:34:26 +00:00
|
|
|
|
2020-04-21 10:22:41 +00:00
|
|
|
for (int i = 0, v = 0; i < renderContext.renderNodes.count(); i++) {
|
|
|
|
RenderNode &renderNode = renderContext.renderNodes[i];
|
|
|
|
if (renderNode.quads.isEmpty() || !renderNode.texture)
|
2013-03-18 15:45:53 +00:00
|
|
|
continue;
|
2013-03-17 12:34:26 +00:00
|
|
|
|
2020-04-21 10:22:41 +00:00
|
|
|
renderNode.firstVertex = v;
|
|
|
|
renderNode.vertexCount = renderNode.quads.count() * verticesPerQuad;
|
2013-03-17 12:34:26 +00:00
|
|
|
|
2020-04-21 10:22:41 +00:00
|
|
|
const QMatrix4x4 matrix = renderNode.texture->matrix(renderNode.coordinateType);
|
2013-03-17 12:34:26 +00:00
|
|
|
|
2020-04-21 10:22:41 +00:00
|
|
|
renderNode.quads.makeInterleavedArrays(primitiveType, &map[v], matrix);
|
|
|
|
v += renderNode.quads.count() * verticesPerQuad;
|
2013-03-18 15:45:53 +00:00
|
|
|
}
|
2013-03-17 12:34:26 +00:00
|
|
|
|
2013-03-18 15:45:53 +00:00
|
|
|
vbo->unmap();
|
|
|
|
vbo->bindArrays();
|
2013-03-17 12:34:26 +00:00
|
|
|
|
2013-03-18 15:45:53 +00:00
|
|
|
// Make sure the blend function is set up correctly in case we will be doing blending
|
|
|
|
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
|
2013-03-17 12:34:26 +00:00
|
|
|
|
2013-03-18 15:45:53 +00:00
|
|
|
float opacity = -1.0;
|
2013-03-17 12:34:26 +00:00
|
|
|
|
2020-04-21 10:22:41 +00:00
|
|
|
for (int i = 0; i < renderContext.renderNodes.count(); i++) {
|
|
|
|
const RenderNode &renderNode = renderContext.renderNodes[i];
|
|
|
|
if (renderNode.vertexCount == 0)
|
2013-03-18 15:45:53 +00:00
|
|
|
continue;
|
2013-03-17 12:34:26 +00:00
|
|
|
|
2020-04-21 10:22:41 +00:00
|
|
|
setBlendEnabled(renderNode.hasAlpha || renderNode.opacity < 1.0);
|
2013-03-17 12:34:26 +00:00
|
|
|
|
2020-04-21 10:22:41 +00:00
|
|
|
if (opacity != renderNode.opacity) {
|
2013-03-18 15:45:53 +00:00
|
|
|
shader->setUniform(GLShader::ModulationConstant,
|
2020-04-21 10:22:41 +00:00
|
|
|
modulate(renderNode.opacity, data.brightness()));
|
|
|
|
opacity = renderNode.opacity;
|
2013-03-17 12:34:26 +00:00
|
|
|
}
|
|
|
|
|
2020-04-21 10:22:41 +00:00
|
|
|
renderNode.texture->setFilter(filter);
|
|
|
|
renderNode.texture->setWrapMode(GL_CLAMP_TO_EDGE);
|
|
|
|
renderNode.texture->bind();
|
2013-03-17 12:34:26 +00:00
|
|
|
|
2020-04-21 10:22:41 +00:00
|
|
|
if (renderNode.leafType == ContentLeaf && useX11TextureClamp) {
|
Avoid texture bleed rendering X11 window
Summary:
We currently see a gap on transformed windows between the window and the
top decoration.
This is partly the atlas bleed on the decoration, and partly a bleed on
the window content itself.
On X11, the window we composite is the frame window - which is a larger
texture containing a transparent border where the frame normally would
be. When we sample with a linear filter we include these texels. Hence
GL_CLAMP_TO_EDGE doesn't work.
Vlad's patch to composite the correct window, not the frame was my
preferred approach, but we had to revert it as it caused an issue with
xwayland :(
Half pixel correction nearly worked, but caused blurry fonts.
This patch resolves it in the fragment shader used by effects doing
transforms. We pass the real texture geometry of the window to the
client with a half pixel correction. Any samples outside the outer half
pixel are then clamped within bounds.
Arguably a hack, but solves the problem in a comparatively
non-invasive way.
BUG: 360549
BUG: 257566
Test Plan:
X11:
Using Vlad's atlas padding for decoration
Slowed animations, wobbled a dark window over a light background
No artifacts
Wayland:
This isn't needed. Now tested that everything still renders the same.
Reviewers: #kwin, zzag
Reviewed By: #kwin, zzag
Subscribers: zzag, jgrulich, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D25737
2020-01-09 13:02:33 +00:00
|
|
|
// X11 windows are reparented to have their buffer in the middle of a larger texture
|
|
|
|
// holding the frame window.
|
|
|
|
// This code passes the texture geometry to the fragment shader
|
|
|
|
// any samples near the edge of the texture will be constrained to be
|
|
|
|
// at least half a pixel in bounds, meaning we don't bleed the transparent border
|
|
|
|
QRectF bufferContentRect = clientShape().boundingRect();
|
|
|
|
bufferContentRect.adjust(0.5, 0.5, -0.5, -0.5);
|
|
|
|
const QRect bufferGeometry = toplevel->bufferGeometry();
|
|
|
|
|
|
|
|
float leftClamp = bufferContentRect.left() / bufferGeometry.width();
|
|
|
|
float topClamp = bufferContentRect.top() / bufferGeometry.height();
|
|
|
|
float rightClamp = bufferContentRect.right() / bufferGeometry.width();
|
|
|
|
float bottomClamp = bufferContentRect.bottom() / bufferGeometry.height();
|
|
|
|
shader->setUniform(GLShader::TextureClamp, QVector4D({leftClamp, topClamp, rightClamp, bottomClamp}));
|
|
|
|
} else {
|
|
|
|
shader->setUniform(GLShader::TextureClamp, QVector4D({0, 0, 1, 1}));
|
|
|
|
}
|
|
|
|
|
2020-04-21 10:22:41 +00:00
|
|
|
vbo->draw(region, primitiveType, renderNode.firstVertex,
|
|
|
|
renderNode.vertexCount, m_hardwareClipping);
|
2013-03-17 12:34:26 +00:00
|
|
|
}
|
|
|
|
|
2013-03-18 15:45:53 +00:00
|
|
|
vbo->unbindArrays();
|
|
|
|
|
2018-01-23 19:27:16 +00:00
|
|
|
setBlendEnabled(false);
|
|
|
|
|
2013-03-17 12:34:26 +00:00
|
|
|
if (!data.shader)
|
|
|
|
ShaderManager::instance()->popShader();
|
|
|
|
|
|
|
|
endRenderWindow();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2020-07-22 17:22:36 +00:00
|
|
|
QSharedPointer<GLTexture> OpenGLWindow::windowTexture()
|
|
|
|
{
|
|
|
|
auto frame = windowPixmap<OpenGLWindowPixmap>();
|
|
|
|
|
2020-07-31 17:49:15 +00:00
|
|
|
if (frame && frame->children().isEmpty()) {
|
2020-07-22 17:22:36 +00:00
|
|
|
return QSharedPointer<GLTexture>(new GLTexture(*frame->texture()));
|
|
|
|
} else {
|
|
|
|
auto effectWindow = window()->effectWindow();
|
2021-01-26 01:56:21 +00:00
|
|
|
const QRect geo = window()->bufferGeometry();
|
|
|
|
QSharedPointer<GLTexture> texture(new GLTexture(GL_RGBA8, geo.size() * window()->bufferScale()));
|
2020-07-22 17:22:36 +00:00
|
|
|
|
|
|
|
QScopedPointer<GLRenderTarget> framebuffer(new KWin::GLRenderTarget(*texture));
|
|
|
|
GLRenderTarget::pushRenderTarget(framebuffer.data());
|
|
|
|
|
|
|
|
auto renderVSG = GLRenderTarget::virtualScreenGeometry();
|
|
|
|
GLVertexBuffer::setVirtualScreenGeometry(geo);
|
|
|
|
GLRenderTarget::setVirtualScreenGeometry(geo);
|
|
|
|
|
|
|
|
QMatrix4x4 mvp;
|
2020-11-27 13:59:48 +00:00
|
|
|
mvp.ortho(geo.x(), geo.x() + geo.width(), geo.y(), geo.y() + geo.height(), -1, 1);
|
2020-07-22 17:22:36 +00:00
|
|
|
|
|
|
|
WindowPaintData data(effectWindow);
|
|
|
|
data.setProjectionMatrix(mvp);
|
|
|
|
|
2020-11-02 08:59:39 +00:00
|
|
|
performPaint(Scene::PAINT_WINDOW_TRANSFORMED, geo, data);
|
2020-07-22 17:22:36 +00:00
|
|
|
GLRenderTarget::popRenderTarget();
|
|
|
|
GLVertexBuffer::setVirtualScreenGeometry(renderVSG);
|
|
|
|
GLRenderTarget::setVirtualScreenGeometry(renderVSG);
|
|
|
|
return texture;
|
|
|
|
}
|
|
|
|
}
|
2012-09-06 10:25:55 +00:00
|
|
|
|
2013-05-10 10:07:56 +00:00
|
|
|
//****************************************
|
|
|
|
// OpenGLWindowPixmap
|
|
|
|
//****************************************
|
|
|
|
|
|
|
|
OpenGLWindowPixmap::OpenGLWindowPixmap(Scene::Window *window, SceneOpenGL* scene)
|
|
|
|
: WindowPixmap(window)
|
|
|
|
, m_texture(scene->createTexture())
|
2016-03-31 08:22:14 +00:00
|
|
|
, m_scene(scene)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2020-10-31 15:09:34 +00:00
|
|
|
OpenGLWindowPixmap::OpenGLWindowPixmap(KWaylandServer::SubSurfaceInterface *subSurface, WindowPixmap *parent, SceneOpenGL *scene)
|
2016-03-31 08:22:14 +00:00
|
|
|
: WindowPixmap(subSurface, parent)
|
|
|
|
, m_texture(scene->createTexture())
|
|
|
|
, m_scene(scene)
|
2013-05-10 10:07:56 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
OpenGLWindowPixmap::~OpenGLWindowPixmap()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2019-08-26 07:44:04 +00:00
|
|
|
static bool needsPixmapUpdate(const OpenGLWindowPixmap *pixmap)
|
|
|
|
{
|
|
|
|
// That's a regular Wayland client.
|
|
|
|
if (pixmap->surface()) {
|
|
|
|
return !pixmap->surface()->trackedDamage().isEmpty();
|
|
|
|
}
|
|
|
|
|
|
|
|
// That's an internal client with a raster buffer attached.
|
|
|
|
if (!pixmap->internalImage().isNull()) {
|
|
|
|
return !pixmap->toplevel()->damage().isEmpty();
|
|
|
|
}
|
|
|
|
|
|
|
|
// That's an internal client with an opengl framebuffer object attached.
|
|
|
|
if (!pixmap->fbo().isNull()) {
|
|
|
|
return !pixmap->toplevel()->damage().isEmpty();
|
|
|
|
}
|
|
|
|
|
|
|
|
// That's an X11 client.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-05-10 10:07:56 +00:00
|
|
|
bool OpenGLWindowPixmap::bind()
|
|
|
|
{
|
|
|
|
if (!m_texture->isNull()) {
|
2019-08-26 07:44:04 +00:00
|
|
|
if (needsPixmapUpdate(this)) {
|
2015-02-11 10:00:12 +00:00
|
|
|
m_texture->updateFromPixmap(this);
|
2013-05-10 10:07:56 +00:00
|
|
|
// mipmaps need to be updated
|
|
|
|
m_texture->setDirty();
|
2016-03-31 08:22:14 +00:00
|
|
|
}
|
2020-10-31 15:09:34 +00:00
|
|
|
if (!subSurface()) {
|
2013-05-10 10:07:56 +00:00
|
|
|
toplevel()->resetDamage();
|
|
|
|
}
|
2016-03-31 08:22:14 +00:00
|
|
|
// also bind all children
|
|
|
|
for (auto it = children().constBegin(); it != children().constEnd(); ++it) {
|
|
|
|
static_cast<OpenGLWindowPixmap*>(*it)->bind();
|
|
|
|
}
|
2013-05-10 10:07:56 +00:00
|
|
|
return true;
|
|
|
|
}
|
2016-03-31 08:22:14 +00:00
|
|
|
for (auto it = children().constBegin(); it != children().constEnd(); ++it) {
|
|
|
|
static_cast<OpenGLWindowPixmap*>(*it)->bind();
|
|
|
|
}
|
2013-05-10 10:07:56 +00:00
|
|
|
if (!isValid()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-02-11 10:00:12 +00:00
|
|
|
bool success = m_texture->load(this);
|
2013-05-10 10:07:56 +00:00
|
|
|
|
2016-03-31 08:22:14 +00:00
|
|
|
if (success) {
|
2020-10-31 15:09:34 +00:00
|
|
|
if (!subSurface()) {
|
2016-03-31 08:22:14 +00:00
|
|
|
toplevel()->resetDamage();
|
|
|
|
}
|
|
|
|
} else
|
2017-09-08 20:30:18 +00:00
|
|
|
qCDebug(KWIN_OPENGL) << "Failed to bind window";
|
2013-05-10 10:07:56 +00:00
|
|
|
return success;
|
|
|
|
}
|
|
|
|
|
2020-10-31 15:09:34 +00:00
|
|
|
WindowPixmap *OpenGLWindowPixmap::createChild(KWaylandServer::SubSurfaceInterface *subSurface)
|
2016-03-31 08:22:14 +00:00
|
|
|
{
|
|
|
|
return new OpenGLWindowPixmap(subSurface, this, m_scene);
|
|
|
|
}
|
|
|
|
|
2016-09-09 07:41:05 +00:00
|
|
|
bool OpenGLWindowPixmap::isValid() const
|
|
|
|
{
|
|
|
|
if (!m_texture->isNull()) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return WindowPixmap::isValid();
|
|
|
|
}
|
|
|
|
|
2010-07-18 16:32:37 +00:00
|
|
|
//****************************************
|
|
|
|
// SceneOpenGL::EffectFrame
|
|
|
|
//****************************************
|
|
|
|
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
GLTexture* SceneOpenGL::EffectFrame::m_unstyledTexture = nullptr;
|
|
|
|
QPixmap* SceneOpenGL::EffectFrame::m_unstyledPixmap = nullptr;
|
2010-07-18 16:32:37 +00:00
|
|
|
|
2012-08-26 15:14:23 +00:00
|
|
|
SceneOpenGL::EffectFrame::EffectFrame(EffectFrameImpl* frame, SceneOpenGL *scene)
|
2011-01-30 14:34:42 +00:00
|
|
|
: Scene::EffectFrame(frame)
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
, m_texture(nullptr)
|
|
|
|
, m_textTexture(nullptr)
|
|
|
|
, m_oldTextTexture(nullptr)
|
|
|
|
, m_textPixmap(nullptr)
|
|
|
|
, m_iconTexture(nullptr)
|
|
|
|
, m_oldIconTexture(nullptr)
|
|
|
|
, m_selectionTexture(nullptr)
|
|
|
|
, m_unstyledVBO(nullptr)
|
2012-08-26 15:14:23 +00:00
|
|
|
, m_scene(scene)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
|
|
|
if (m_effectFrame->style() == EffectFrameUnstyled && !m_unstyledTexture) {
|
2010-07-18 16:32:37 +00:00
|
|
|
updateUnstyledTexture();
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
SceneOpenGL::EffectFrame::~EffectFrame()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-07-18 16:32:37 +00:00
|
|
|
delete m_texture;
|
|
|
|
delete m_textTexture;
|
2010-10-10 11:26:00 +00:00
|
|
|
delete m_textPixmap;
|
2010-08-07 14:08:34 +00:00
|
|
|
delete m_oldTextTexture;
|
2010-07-20 21:11:03 +00:00
|
|
|
delete m_iconTexture;
|
2010-08-07 14:08:34 +00:00
|
|
|
delete m_oldIconTexture;
|
2010-07-26 20:00:04 +00:00
|
|
|
delete m_selectionTexture;
|
2010-07-24 08:04:17 +00:00
|
|
|
delete m_unstyledVBO;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
void SceneOpenGL::EffectFrame::free()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2011-04-24 18:20:01 +00:00
|
|
|
glFlush();
|
2010-07-18 16:32:37 +00:00
|
|
|
delete m_texture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_texture = nullptr;
|
2010-07-18 16:32:37 +00:00
|
|
|
delete m_textTexture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_textTexture = nullptr;
|
2010-10-10 11:26:00 +00:00
|
|
|
delete m_textPixmap;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_textPixmap = nullptr;
|
2010-07-20 21:11:03 +00:00
|
|
|
delete m_iconTexture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_iconTexture = nullptr;
|
2010-07-26 20:00:04 +00:00
|
|
|
delete m_selectionTexture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_selectionTexture = nullptr;
|
2010-07-24 08:04:17 +00:00
|
|
|
delete m_unstyledVBO;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_unstyledVBO = nullptr;
|
2010-08-07 14:08:34 +00:00
|
|
|
delete m_oldIconTexture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_oldIconTexture = nullptr;
|
2010-08-07 14:08:34 +00:00
|
|
|
delete m_oldTextTexture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_oldTextTexture = nullptr;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-20 21:11:03 +00:00
|
|
|
|
|
|
|
void SceneOpenGL::EffectFrame::freeIconFrame()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-07-20 21:11:03 +00:00
|
|
|
delete m_iconTexture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_iconTexture = nullptr;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
void SceneOpenGL::EffectFrame::freeTextFrame()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-07-18 16:32:37 +00:00
|
|
|
delete m_textTexture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_textTexture = nullptr;
|
2010-10-10 11:26:00 +00:00
|
|
|
delete m_textPixmap;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_textPixmap = nullptr;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
2010-07-26 20:00:04 +00:00
|
|
|
void SceneOpenGL::EffectFrame::freeSelection()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-07-26 20:00:04 +00:00
|
|
|
delete m_selectionTexture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_selectionTexture = nullptr;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-26 20:00:04 +00:00
|
|
|
|
2010-08-07 14:08:34 +00:00
|
|
|
void SceneOpenGL::EffectFrame::crossFadeIcon()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-08-07 14:08:34 +00:00
|
|
|
delete m_oldIconTexture;
|
|
|
|
m_oldIconTexture = m_iconTexture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_iconTexture = nullptr;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-08-07 14:08:34 +00:00
|
|
|
|
|
|
|
void SceneOpenGL::EffectFrame::crossFadeText()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-08-07 14:08:34 +00:00
|
|
|
delete m_oldTextTexture;
|
|
|
|
m_oldTextTexture = m_textTexture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_textTexture = nullptr;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-08-07 14:08:34 +00:00
|
|
|
|
2020-03-13 16:41:56 +00:00
|
|
|
void SceneOpenGL::EffectFrame::render(const QRegion &_region, double opacity, double frameOpacity)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
|
|
|
if (m_effectFrame->geometry().isEmpty())
|
2010-07-18 16:32:37 +00:00
|
|
|
return; // Nothing to display
|
|
|
|
|
2020-03-13 16:41:56 +00:00
|
|
|
Q_UNUSED(_region);
|
|
|
|
const QRegion region = infiniteRegion(); // TODO: Old region doesn't seem to work with OpenGL
|
2010-07-18 16:32:37 +00:00
|
|
|
|
2010-07-24 16:29:16 +00:00
|
|
|
GLShader* shader = m_effectFrame->shader();
|
2014-02-25 10:02:32 +00:00
|
|
|
if (!shader) {
|
2015-11-27 15:48:53 +00:00
|
|
|
shader = ShaderManager::instance()->pushShader(ShaderTrait::MapTexture | ShaderTrait::Modulate);
|
2011-01-06 18:55:26 +00:00
|
|
|
} else if (shader) {
|
|
|
|
ShaderManager::instance()->pushShader(shader);
|
|
|
|
}
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (shader) {
|
2011-02-12 00:36:21 +00:00
|
|
|
shader->setUniform(GLShader::ModulationConstant, QVector4D(1.0, 1.0, 1.0, 1.0));
|
2011-02-10 18:37:51 +00:00
|
|
|
shader->setUniform(GLShader::Saturation, 1.0f);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2015-11-27 15:48:53 +00:00
|
|
|
const QMatrix4x4 projection = m_scene->projectionMatrix();
|
2010-07-24 16:29:16 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
glEnable(GL_BLEND);
|
|
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
// Render the actual frame
|
2011-01-30 14:34:42 +00:00
|
|
|
if (m_effectFrame->style() == EffectFrameUnstyled) {
|
|
|
|
if (!m_unstyledVBO) {
|
|
|
|
m_unstyledVBO = new GLVertexBuffer(GLVertexBuffer::Static);
|
2010-12-04 10:01:57 +00:00
|
|
|
QRect area = m_effectFrame->geometry();
|
2011-01-30 14:34:42 +00:00
|
|
|
area.moveTo(0, 0);
|
|
|
|
area.adjust(-5, -5, 5, 5);
|
|
|
|
|
2010-07-24 08:04:17 +00:00
|
|
|
const int roundness = 5;
|
|
|
|
QVector<float> verts, texCoords;
|
2011-01-30 14:34:42 +00:00
|
|
|
verts.reserve(84);
|
|
|
|
texCoords.reserve(84);
|
2010-07-24 08:04:17 +00:00
|
|
|
|
|
|
|
// top left
|
|
|
|
verts << area.left() << area.top();
|
|
|
|
texCoords << 0.0f << 0.0f;
|
|
|
|
verts << area.left() << area.top() + roundness;
|
|
|
|
texCoords << 0.0f << 0.5f;
|
|
|
|
verts << area.left() + roundness << area.top();
|
|
|
|
texCoords << 0.5f << 0.0f;
|
|
|
|
verts << area.left() + roundness << area.top() + roundness;
|
|
|
|
texCoords << 0.5f << 0.5f;
|
|
|
|
verts << area.left() << area.top() + roundness;
|
|
|
|
texCoords << 0.0f << 0.5f;
|
|
|
|
verts << area.left() + roundness << area.top();
|
|
|
|
texCoords << 0.5f << 0.0f;
|
|
|
|
// top
|
|
|
|
verts << area.left() + roundness << area.top();
|
|
|
|
texCoords << 0.5f << 0.0f;
|
|
|
|
verts << area.left() + roundness << area.top() + roundness;
|
|
|
|
texCoords << 0.5f << 0.5f;
|
|
|
|
verts << area.right() - roundness << area.top();
|
|
|
|
texCoords << 0.5f << 0.0f;
|
|
|
|
verts << area.left() + roundness << area.top() + roundness;
|
|
|
|
texCoords << 0.5f << 0.5f;
|
|
|
|
verts << area.right() - roundness << area.top() + roundness;
|
|
|
|
texCoords << 0.5f << 0.5f;
|
|
|
|
verts << area.right() - roundness << area.top();
|
|
|
|
texCoords << 0.5f << 0.0f;
|
|
|
|
// top right
|
|
|
|
verts << area.right() - roundness << area.top();
|
|
|
|
texCoords << 0.5f << 0.0f;
|
|
|
|
verts << area.right() - roundness << area.top() + roundness;
|
|
|
|
texCoords << 0.5f << 0.5f;
|
|
|
|
verts << area.right() << area.top();
|
|
|
|
texCoords << 1.0f << 0.0f;
|
|
|
|
verts << area.right() - roundness << area.top() + roundness;
|
|
|
|
texCoords << 0.5f << 0.5f;
|
|
|
|
verts << area.right() << area.top() + roundness;
|
|
|
|
texCoords << 1.0f << 0.5f;
|
|
|
|
verts << area.right() << area.top();
|
|
|
|
texCoords << 1.0f << 0.0f;
|
|
|
|
// bottom left
|
|
|
|
verts << area.left() << area.bottom() - roundness;
|
|
|
|
texCoords << 0.0f << 0.5f;
|
|
|
|
verts << area.left() << area.bottom();
|
|
|
|
texCoords << 0.0f << 1.0f;
|
|
|
|
verts << area.left() + roundness << area.bottom() - roundness;
|
|
|
|
texCoords << 0.5f << 0.5f;
|
|
|
|
verts << area.left() + roundness << area.bottom();
|
|
|
|
texCoords << 0.5f << 1.0f;
|
|
|
|
verts << area.left() << area.bottom();
|
|
|
|
texCoords << 0.0f << 1.0f;
|
|
|
|
verts << area.left() + roundness << area.bottom() - roundness;
|
|
|
|
texCoords << 0.5f << 0.5f;
|
|
|
|
// bottom
|
|
|
|
verts << area.left() + roundness << area.bottom() - roundness;
|
|
|
|
texCoords << 0.5f << 0.5f;
|
|
|
|
verts << area.left() + roundness << area.bottom();
|
|
|
|
texCoords << 0.5f << 1.0f;
|
|
|
|
verts << area.right() - roundness << area.bottom() - roundness;
|
|
|
|
texCoords << 0.5f << 0.5f;
|
|
|
|
verts << area.left() + roundness << area.bottom();
|
|
|
|
texCoords << 0.5f << 1.0f;
|
|
|
|
verts << area.right() - roundness << area.bottom();
|
|
|
|
texCoords << 0.5f << 1.0f;
|
|
|
|
verts << area.right() - roundness << area.bottom() - roundness;
|
|
|
|
texCoords << 0.5f << 0.5f;
|
|
|
|
// bottom right
|
|
|
|
verts << area.right() - roundness << area.bottom() - roundness;
|
|
|
|
texCoords << 0.5f << 0.5f;
|
|
|
|
verts << area.right() - roundness << area.bottom();
|
|
|
|
texCoords << 0.5f << 1.0f;
|
|
|
|
verts << area.right() << area.bottom() - roundness;
|
|
|
|
texCoords << 1.0f << 0.5f;
|
|
|
|
verts << area.right() - roundness << area.bottom();
|
|
|
|
texCoords << 0.5f << 1.0f;
|
|
|
|
verts << area.right() << area.bottom();
|
|
|
|
texCoords << 1.0f << 1.0f;
|
|
|
|
verts << area.right() << area.bottom() - roundness;
|
|
|
|
texCoords << 1.0f << 0.5f;
|
|
|
|
// center
|
|
|
|
verts << area.left() << area.top() + roundness;
|
|
|
|
texCoords << 0.0f << 0.5f;
|
|
|
|
verts << area.left() << area.bottom() - roundness;
|
|
|
|
texCoords << 0.0f << 0.5f;
|
|
|
|
verts << area.right() << area.top() + roundness;
|
|
|
|
texCoords << 1.0f << 0.5f;
|
|
|
|
verts << area.left() << area.bottom() - roundness;
|
|
|
|
texCoords << 0.0f << 0.5f;
|
|
|
|
verts << area.right() << area.bottom() - roundness;
|
|
|
|
texCoords << 1.0f << 0.5f;
|
|
|
|
verts << area.right() << area.top() + roundness;
|
|
|
|
texCoords << 1.0f << 0.5f;
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
m_unstyledVBO->setData(verts.count() / 2, 2, verts.data(), texCoords.data());
|
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
2011-02-12 00:36:21 +00:00
|
|
|
if (shader) {
|
|
|
|
const float a = opacity * frameOpacity;
|
|
|
|
shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
|
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
m_unstyledTexture->bind();
|
2010-12-04 10:01:57 +00:00
|
|
|
const QPoint pt = m_effectFrame->geometry().topLeft();
|
2015-11-27 15:48:53 +00:00
|
|
|
|
|
|
|
QMatrix4x4 mvp(projection);
|
|
|
|
mvp.translate(pt.x(), pt.y());
|
|
|
|
shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
m_unstyledVBO->render(region, GL_TRIANGLES);
|
2010-07-18 16:32:37 +00:00
|
|
|
m_unstyledTexture->unbind();
|
2011-01-30 14:34:42 +00:00
|
|
|
} else if (m_effectFrame->style() == EffectFrameStyled) {
|
|
|
|
if (!m_texture) // Lazy creation
|
2010-07-18 16:32:37 +00:00
|
|
|
updateTexture();
|
|
|
|
|
2011-02-12 00:36:21 +00:00
|
|
|
if (shader) {
|
|
|
|
const float a = opacity * frameOpacity;
|
|
|
|
shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
|
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
m_texture->bind();
|
|
|
|
qreal left, top, right, bottom;
|
2011-01-30 14:34:42 +00:00
|
|
|
m_effectFrame->frame().getMargins(left, top, right, bottom); // m_geometry is the inner geometry
|
2015-11-27 15:48:53 +00:00
|
|
|
const QRect rect = m_effectFrame->geometry().adjusted(-left, -top, right, bottom);
|
|
|
|
|
|
|
|
QMatrix4x4 mvp(projection);
|
|
|
|
mvp.translate(rect.x(), rect.y());
|
|
|
|
shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
|
|
|
|
|
|
|
|
m_texture->render(region, rect);
|
2010-07-18 16:32:37 +00:00
|
|
|
m_texture->unbind();
|
2010-07-26 20:00:04 +00:00
|
|
|
|
2011-04-28 11:41:11 +00:00
|
|
|
}
|
|
|
|
if (!m_effectFrame->selection().isNull()) {
|
|
|
|
if (!m_selectionTexture) { // Lazy creation
|
|
|
|
QPixmap pixmap = m_effectFrame->selectionFrame().framePixmap();
|
2011-06-11 12:48:16 +00:00
|
|
|
if (!pixmap.isNull())
|
2014-11-23 13:33:19 +00:00
|
|
|
m_selectionTexture = new GLTexture(pixmap);
|
2011-04-28 11:41:11 +00:00
|
|
|
}
|
2011-06-11 12:48:16 +00:00
|
|
|
if (m_selectionTexture) {
|
|
|
|
if (shader) {
|
|
|
|
const float a = opacity * frameOpacity;
|
|
|
|
shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
|
|
|
|
}
|
2015-11-27 15:48:53 +00:00
|
|
|
QMatrix4x4 mvp(projection);
|
|
|
|
mvp.translate(m_effectFrame->selection().x(), m_effectFrame->selection().y());
|
|
|
|
shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
|
2011-06-11 12:48:16 +00:00
|
|
|
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
|
|
|
|
m_selectionTexture->bind();
|
|
|
|
m_selectionTexture->render(region, m_effectFrame->selection());
|
|
|
|
m_selectionTexture->unbind();
|
|
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
2010-07-18 16:32:37 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
// Render icon
|
2011-01-30 14:34:42 +00:00
|
|
|
if (!m_effectFrame->icon().isNull() && !m_effectFrame->iconSize().isEmpty()) {
|
|
|
|
QPoint topLeft(m_effectFrame->geometry().x(),
|
|
|
|
m_effectFrame->geometry().center().y() - m_effectFrame->iconSize().height() / 2);
|
|
|
|
|
2015-11-27 15:48:53 +00:00
|
|
|
QMatrix4x4 mvp(projection);
|
|
|
|
mvp.translate(topLeft.x(), topLeft.y());
|
|
|
|
shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (m_effectFrame->isCrossFade() && m_oldIconTexture) {
|
2011-02-12 00:36:21 +00:00
|
|
|
if (shader) {
|
|
|
|
const float a = opacity * (1.0 - m_effectFrame->crossFadeProgress());
|
|
|
|
shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
|
|
|
|
}
|
2010-08-07 14:08:34 +00:00
|
|
|
|
|
|
|
m_oldIconTexture->bind();
|
2011-01-30 14:34:42 +00:00
|
|
|
m_oldIconTexture->render(region, QRect(topLeft, m_effectFrame->iconSize()));
|
2010-08-07 14:08:34 +00:00
|
|
|
m_oldIconTexture->unbind();
|
2011-02-12 00:36:21 +00:00
|
|
|
if (shader) {
|
|
|
|
const float a = opacity * m_effectFrame->crossFadeProgress();
|
|
|
|
shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
} else {
|
2011-02-12 00:36:21 +00:00
|
|
|
if (shader) {
|
|
|
|
const QVector4D constant(opacity, opacity, opacity, opacity);
|
|
|
|
shader->setUniform(GLShader::ModulationConstant, constant);
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-08-07 14:08:34 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (!m_iconTexture) { // lazy creation
|
2014-11-23 13:33:19 +00:00
|
|
|
m_iconTexture = new GLTexture(m_effectFrame->icon().pixmap(m_effectFrame->iconSize()));
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-20 21:11:03 +00:00
|
|
|
m_iconTexture->bind();
|
2011-01-30 14:34:42 +00:00
|
|
|
m_iconTexture->render(region, QRect(topLeft, m_effectFrame->iconSize()));
|
2010-07-20 21:11:03 +00:00
|
|
|
m_iconTexture->unbind();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
// Render text
|
2011-01-30 14:34:42 +00:00
|
|
|
if (!m_effectFrame->text().isEmpty()) {
|
2015-11-27 15:48:53 +00:00
|
|
|
QMatrix4x4 mvp(projection);
|
|
|
|
mvp.translate(m_effectFrame->geometry().x(), m_effectFrame->geometry().y());
|
|
|
|
shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
|
2011-01-30 14:34:42 +00:00
|
|
|
if (m_effectFrame->isCrossFade() && m_oldTextTexture) {
|
2011-02-12 00:36:21 +00:00
|
|
|
if (shader) {
|
|
|
|
const float a = opacity * (1.0 - m_effectFrame->crossFadeProgress());
|
|
|
|
shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
|
|
|
|
}
|
2010-08-07 14:08:34 +00:00
|
|
|
|
|
|
|
m_oldTextTexture->bind();
|
2011-01-30 14:34:42 +00:00
|
|
|
m_oldTextTexture->render(region, m_effectFrame->geometry());
|
2010-08-07 14:08:34 +00:00
|
|
|
m_oldTextTexture->unbind();
|
2011-02-12 00:36:21 +00:00
|
|
|
if (shader) {
|
|
|
|
const float a = opacity * m_effectFrame->crossFadeProgress();
|
|
|
|
shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
} else {
|
2011-02-12 00:36:21 +00:00
|
|
|
if (shader) {
|
|
|
|
const QVector4D constant(opacity, opacity, opacity, opacity);
|
|
|
|
shader->setUniform(GLShader::ModulationConstant, constant);
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
if (!m_textTexture) // Lazy creation
|
2010-07-18 16:32:37 +00:00
|
|
|
updateTextTexture();
|
2016-04-08 07:26:12 +00:00
|
|
|
|
|
|
|
if (m_textTexture) {
|
|
|
|
m_textTexture->bind();
|
|
|
|
m_textTexture->render(region, m_effectFrame->geometry());
|
|
|
|
m_textTexture->unbind();
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
2010-12-11 09:57:29 +00:00
|
|
|
if (shader) {
|
|
|
|
ShaderManager::instance()->popShader();
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
glDisable(GL_BLEND);
|
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
void SceneOpenGL::EffectFrame::updateTexture()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-07-18 16:32:37 +00:00
|
|
|
delete m_texture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_texture = nullptr;
|
2011-01-30 14:34:42 +00:00
|
|
|
if (m_effectFrame->style() == EffectFrameStyled) {
|
2010-07-26 20:16:54 +00:00
|
|
|
QPixmap pixmap = m_effectFrame->frame().framePixmap();
|
2014-11-23 13:33:19 +00:00
|
|
|
m_texture = new GLTexture(pixmap);
|
2010-07-18 16:32:37 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
void SceneOpenGL::EffectFrame::updateTextTexture()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-07-18 16:32:37 +00:00
|
|
|
delete m_textTexture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_textTexture = nullptr;
|
2010-10-10 11:26:00 +00:00
|
|
|
delete m_textPixmap;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_textPixmap = nullptr;
|
2010-07-18 16:32:37 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (m_effectFrame->text().isEmpty())
|
2010-07-18 16:32:37 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
// Determine position on texture to paint text
|
2011-01-30 14:34:42 +00:00
|
|
|
QRect rect(QPoint(0, 0), m_effectFrame->geometry().size());
|
|
|
|
if (!m_effectFrame->icon().isNull() && !m_effectFrame->iconSize().isEmpty())
|
|
|
|
rect.setLeft(m_effectFrame->iconSize().width());
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
// If static size elide text as required
|
|
|
|
QString text = m_effectFrame->text();
|
2011-01-30 14:34:42 +00:00
|
|
|
if (m_effectFrame->isStatic()) {
|
|
|
|
QFontMetrics metrics(m_effectFrame->font());
|
|
|
|
text = metrics.elidedText(text, Qt::ElideRight, rect.width());
|
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
m_textPixmap = new QPixmap(m_effectFrame->geometry().size());
|
|
|
|
m_textPixmap->fill(Qt::transparent);
|
|
|
|
QPainter p(m_textPixmap);
|
|
|
|
p.setFont(m_effectFrame->font());
|
|
|
|
if (m_effectFrame->style() == EffectFrameStyled)
|
|
|
|
p.setPen(m_effectFrame->styledTextColor());
|
2010-07-18 16:32:37 +00:00
|
|
|
else // TODO: What about no frame? Custom color setting required
|
2011-01-30 14:34:42 +00:00
|
|
|
p.setPen(Qt::white);
|
|
|
|
p.drawText(rect, m_effectFrame->alignment(), text);
|
2010-07-18 16:32:37 +00:00
|
|
|
p.end();
|
2014-11-23 13:33:19 +00:00
|
|
|
m_textTexture = new GLTexture(*m_textPixmap);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
void SceneOpenGL::EffectFrame::updateUnstyledTexture()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-07-18 16:32:37 +00:00
|
|
|
delete m_unstyledTexture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_unstyledTexture = nullptr;
|
2010-10-10 11:26:00 +00:00
|
|
|
delete m_unstyledPixmap;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_unstyledPixmap = nullptr;
|
2010-07-18 16:32:37 +00:00
|
|
|
// Based off circle() from kwinxrenderutils.cpp
|
2020-12-11 17:07:18 +00:00
|
|
|
const int CS = 8;
|
2011-01-30 14:34:42 +00:00
|
|
|
m_unstyledPixmap = new QPixmap(2 * CS, 2 * CS);
|
|
|
|
m_unstyledPixmap->fill(Qt::transparent);
|
|
|
|
QPainter p(m_unstyledPixmap);
|
|
|
|
p.setRenderHint(QPainter::Antialiasing);
|
|
|
|
p.setPen(Qt::NoPen);
|
|
|
|
p.setBrush(Qt::black);
|
|
|
|
p.drawEllipse(m_unstyledPixmap->rect());
|
2010-07-18 16:32:37 +00:00
|
|
|
p.end();
|
2012-08-26 15:14:23 +00:00
|
|
|
m_unstyledTexture = new GLTexture(*m_unstyledPixmap);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
void SceneOpenGL::EffectFrame::cleanup()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-07-18 16:32:37 +00:00
|
|
|
delete m_unstyledTexture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_unstyledTexture = nullptr;
|
2010-10-10 11:26:00 +00:00
|
|
|
delete m_unstyledPixmap;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_unstyledPixmap = nullptr;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
2011-03-27 10:33:07 +00:00
|
|
|
//****************************************
|
|
|
|
// SceneOpenGL::Shadow
|
|
|
|
//****************************************
|
2014-12-04 09:36:19 +00:00
|
|
|
class DecorationShadowTextureCache
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
~DecorationShadowTextureCache();
|
|
|
|
DecorationShadowTextureCache(const DecorationShadowTextureCache&) = delete;
|
|
|
|
static DecorationShadowTextureCache &instance();
|
|
|
|
|
|
|
|
void unregister(SceneOpenGLShadow *shadow);
|
|
|
|
QSharedPointer<GLTexture> getTexture(SceneOpenGLShadow *shadow);
|
|
|
|
|
|
|
|
private:
|
|
|
|
DecorationShadowTextureCache() = default;
|
|
|
|
struct Data {
|
|
|
|
QSharedPointer<GLTexture> texture;
|
|
|
|
QVector<SceneOpenGLShadow*> shadows;
|
|
|
|
};
|
|
|
|
QHash<KDecoration2::DecorationShadow*, Data> m_cache;
|
|
|
|
};
|
|
|
|
|
|
|
|
DecorationShadowTextureCache &DecorationShadowTextureCache::instance()
|
|
|
|
{
|
|
|
|
static DecorationShadowTextureCache s_instance;
|
|
|
|
return s_instance;
|
|
|
|
}
|
|
|
|
|
|
|
|
DecorationShadowTextureCache::~DecorationShadowTextureCache()
|
|
|
|
{
|
|
|
|
Q_ASSERT(m_cache.isEmpty());
|
|
|
|
}
|
|
|
|
|
|
|
|
void DecorationShadowTextureCache::unregister(SceneOpenGLShadow *shadow)
|
|
|
|
{
|
|
|
|
auto it = m_cache.begin();
|
|
|
|
while (it != m_cache.end()) {
|
|
|
|
auto &d = it.value();
|
|
|
|
// check whether the Vector of Shadows contains our shadow and remove all of them
|
|
|
|
auto glIt = d.shadows.begin();
|
|
|
|
while (glIt != d.shadows.end()) {
|
|
|
|
if (*glIt == shadow) {
|
|
|
|
glIt = d.shadows.erase(glIt);
|
|
|
|
} else {
|
|
|
|
glIt++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// if there are no shadows any more we can erase the cache entry
|
|
|
|
if (d.shadows.isEmpty()) {
|
|
|
|
it = m_cache.erase(it);
|
|
|
|
} else {
|
|
|
|
it++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
QSharedPointer<GLTexture> DecorationShadowTextureCache::getTexture(SceneOpenGLShadow *shadow)
|
|
|
|
{
|
|
|
|
Q_ASSERT(shadow->hasDecorationShadow());
|
|
|
|
unregister(shadow);
|
2020-03-15 19:59:29 +00:00
|
|
|
const auto &decoShadow = shadow->decorationShadow().toStrongRef();
|
2014-12-04 09:36:19 +00:00
|
|
|
Q_ASSERT(!decoShadow.isNull());
|
|
|
|
auto it = m_cache.find(decoShadow.data());
|
|
|
|
if (it != m_cache.end()) {
|
|
|
|
Q_ASSERT(!it.value().shadows.contains(shadow));
|
|
|
|
it.value().shadows << shadow;
|
|
|
|
return it.value().texture;
|
|
|
|
}
|
|
|
|
Data d;
|
|
|
|
d.shadows << shadow;
|
|
|
|
d.texture = QSharedPointer<GLTexture>::create(shadow->decorationShadowImage());
|
|
|
|
m_cache.insert(decoShadow.data(), d);
|
|
|
|
return d.texture;
|
|
|
|
}
|
|
|
|
|
2011-03-27 10:33:07 +00:00
|
|
|
SceneOpenGLShadow::SceneOpenGLShadow(Toplevel *toplevel)
|
|
|
|
: Shadow(toplevel)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
SceneOpenGLShadow::~SceneOpenGLShadow()
|
|
|
|
{
|
2018-12-02 11:59:45 +00:00
|
|
|
Scene *scene = Compositor::self()->scene();
|
|
|
|
if (scene) {
|
|
|
|
scene->makeOpenGLContextCurrent();
|
2015-12-20 23:18:00 +00:00
|
|
|
DecorationShadowTextureCache::instance().unregister(this);
|
|
|
|
m_texture.reset();
|
|
|
|
}
|
2011-03-27 10:33:07 +00:00
|
|
|
}
|
|
|
|
|
[scenes/opengl] Correctly draw shadows when corner tiles are missing
Summary:
Current implementation of buildQuads assumes that corner shadow tiles
are always present:
const QRectF leftRect(
topLeftRect.bottomLeft(),
bottomLeftRect.topRight());
but that assumption is wrong. For example, if the default panel is on
the bottom screen edge, then the calendar popup won't have the
bottom-left shadow tile(at least on Wayland). Which means that the left
shadow tile won't be visible because
topLeftRect.left() == bottomLeftRect.right().
Corner rectangles only have to influence height of the left/right tile
and width of the top/bottom tile. Width of the left/right tile and
height of the top/bottom tile should not be controlled by corner tiles.
Overall, this is how shadow quads are computed:
* Compute the outer rectangle;
* Compute target rectangle for each corner tile. If some corner tile is
missing, move the target rectangle to the corresponding corner of the
inner shadow rect and set its width and height to 0. We need to do
that to prevent top/right/bottom/left tiles from spanning over
corners:
{F6190219, layout=center, size=full}
We would rather prefer something like this if the top-left tile is
missing:
{F6190233, layout=center, size=full}
* Fix overlaps between corner tiles;
* Compute target rectangles for top, right, bottom, and left tiles;
* Fix overlaps between left/right and top/bottom shadow tiles.
Test Plan:
* Ran tests;
* Resized Konsole to its minimimum size(on X11 and Wayland);
* Opened the calendar popup(on X11 and Wayland):
Before:
{F6190344, layout=center, size=full}
After:
{F6190346, layout=center, size=full}
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: abetts, davidedmundson, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14783
2018-08-12 18:23:12 +00:00
|
|
|
static inline void distributeHorizontally(QRectF &leftRect, QRectF &rightRect)
|
|
|
|
{
|
|
|
|
if (leftRect.right() > rightRect.left()) {
|
|
|
|
const qreal boundedRight = qMin(leftRect.right(), rightRect.right());
|
|
|
|
const qreal boundedLeft = qMax(leftRect.left(), rightRect.left());
|
|
|
|
const qreal halfOverlap = (boundedRight - boundedLeft) / 2.0;
|
|
|
|
leftRect.setRight(boundedRight - halfOverlap);
|
|
|
|
rightRect.setLeft(boundedLeft + halfOverlap);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void distributeVertically(QRectF &topRect, QRectF &bottomRect)
|
|
|
|
{
|
|
|
|
if (topRect.bottom() > bottomRect.top()) {
|
|
|
|
const qreal boundedBottom = qMin(topRect.bottom(), bottomRect.bottom());
|
|
|
|
const qreal boundedTop = qMax(topRect.top(), bottomRect.top());
|
|
|
|
const qreal halfOverlap = (boundedBottom - boundedTop) / 2.0;
|
|
|
|
topRect.setBottom(boundedBottom - halfOverlap);
|
|
|
|
bottomRect.setTop(boundedTop + halfOverlap);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-23 17:06:12 +00:00
|
|
|
void SceneOpenGLShadow::buildQuads()
|
2011-03-27 10:33:07 +00:00
|
|
|
{
|
[scenes/opengl] Fix overlapping shadow tiles
Summary:
This problem appears if shadow corner tiles are too big and
some window has size smaller than 2 * shadowTileSize.
This change tries to address the problem above by exclusing
overlapping tile parts. If there are any two overlapping corners
then tile between them(top/right/bottom/left) is not rendered.
Also, because some corner tile parts can be excluded, corner tiles
are expected to be symmetrical(i.e. if we remove right half from
the top-left tile and left half from the top-right tile and
stick them together, they still look fine, there are no misalignments, etc).
Most shadows(e.g. shadows from Breeze) have such behaviour.
No tiles are overlapping
{F5728514, layout=center, size=full}
Overlapping tiles
{F5728516, layout=center, size=full}
And this is how it supposed to be
{F5728517, layout=center, size=full}
Test Plan:
* apply D11069 to Breeze
* in System Settings/Application Style/Window Decorations, choose "Very Large" shadow size
* open Konsole
* resize it to a minimum possible size
Reviewers: #kwin, graesslin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, ngraham, anemeth, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D10811
2018-06-07 08:48:05 +00:00
|
|
|
// Do not draw shadows if window width or window height is less than
|
|
|
|
// 5 px. 5 is an arbitrary choice.
|
|
|
|
if (topLevel()->width() < 5 || topLevel()->height() < 5) {
|
|
|
|
m_shadowQuads.clear();
|
|
|
|
setShadowRegion(QRegion());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-07-24 06:39:25 +00:00
|
|
|
const QSizeF top(elementSize(ShadowElementTop));
|
|
|
|
const QSizeF topRight(elementSize(ShadowElementTopRight));
|
|
|
|
const QSizeF right(elementSize(ShadowElementRight));
|
|
|
|
const QSizeF bottomRight(elementSize(ShadowElementBottomRight));
|
|
|
|
const QSizeF bottom(elementSize(ShadowElementBottom));
|
|
|
|
const QSizeF bottomLeft(elementSize(ShadowElementBottomLeft));
|
|
|
|
const QSizeF left(elementSize(ShadowElementLeft));
|
|
|
|
const QSizeF topLeft(elementSize(ShadowElementTopLeft));
|
2011-11-25 14:03:21 +00:00
|
|
|
|
[scenes/opengl] Correctly draw shadows when corner tiles are missing
Summary:
Current implementation of buildQuads assumes that corner shadow tiles
are always present:
const QRectF leftRect(
topLeftRect.bottomLeft(),
bottomLeftRect.topRight());
but that assumption is wrong. For example, if the default panel is on
the bottom screen edge, then the calendar popup won't have the
bottom-left shadow tile(at least on Wayland). Which means that the left
shadow tile won't be visible because
topLeftRect.left() == bottomLeftRect.right().
Corner rectangles only have to influence height of the left/right tile
and width of the top/bottom tile. Width of the left/right tile and
height of the top/bottom tile should not be controlled by corner tiles.
Overall, this is how shadow quads are computed:
* Compute the outer rectangle;
* Compute target rectangle for each corner tile. If some corner tile is
missing, move the target rectangle to the corresponding corner of the
inner shadow rect and set its width and height to 0. We need to do
that to prevent top/right/bottom/left tiles from spanning over
corners:
{F6190219, layout=center, size=full}
We would rather prefer something like this if the top-left tile is
missing:
{F6190233, layout=center, size=full}
* Fix overlaps between corner tiles;
* Compute target rectangles for top, right, bottom, and left tiles;
* Fix overlaps between left/right and top/bottom shadow tiles.
Test Plan:
* Ran tests;
* Resized Konsole to its minimimum size(on X11 and Wayland);
* Opened the calendar popup(on X11 and Wayland):
Before:
{F6190344, layout=center, size=full}
After:
{F6190346, layout=center, size=full}
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: abetts, davidedmundson, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14783
2018-08-12 18:23:12 +00:00
|
|
|
const QMarginsF shadowMargins(
|
|
|
|
std::max({topLeft.width(), left.width(), bottomLeft.width()}),
|
|
|
|
std::max({topLeft.height(), top.height(), topRight.height()}),
|
|
|
|
std::max({topRight.width(), right.width(), bottomRight.width()}),
|
|
|
|
std::max({bottomRight.height(), bottom.height(), bottomLeft.height()}));
|
|
|
|
|
2012-02-08 18:31:17 +00:00
|
|
|
const QRectF outerRect(QPointF(-leftOffset(), -topOffset()),
|
[scenes/opengl] Fix overlapping shadow tiles
Summary:
This problem appears if shadow corner tiles are too big and
some window has size smaller than 2 * shadowTileSize.
This change tries to address the problem above by exclusing
overlapping tile parts. If there are any two overlapping corners
then tile between them(top/right/bottom/left) is not rendered.
Also, because some corner tile parts can be excluded, corner tiles
are expected to be symmetrical(i.e. if we remove right half from
the top-left tile and left half from the top-right tile and
stick them together, they still look fine, there are no misalignments, etc).
Most shadows(e.g. shadows from Breeze) have such behaviour.
No tiles are overlapping
{F5728514, layout=center, size=full}
Overlapping tiles
{F5728516, layout=center, size=full}
And this is how it supposed to be
{F5728517, layout=center, size=full}
Test Plan:
* apply D11069 to Breeze
* in System Settings/Application Style/Window Decorations, choose "Very Large" shadow size
* open Konsole
* resize it to a minimum possible size
Reviewers: #kwin, graesslin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, ngraham, anemeth, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D10811
2018-06-07 08:48:05 +00:00
|
|
|
QPointF(topLevel()->width() + rightOffset(),
|
|
|
|
topLevel()->height() + bottomOffset()));
|
|
|
|
|
[scenes/opengl] Correctly draw shadows when corner tiles are missing
Summary:
Current implementation of buildQuads assumes that corner shadow tiles
are always present:
const QRectF leftRect(
topLeftRect.bottomLeft(),
bottomLeftRect.topRight());
but that assumption is wrong. For example, if the default panel is on
the bottom screen edge, then the calendar popup won't have the
bottom-left shadow tile(at least on Wayland). Which means that the left
shadow tile won't be visible because
topLeftRect.left() == bottomLeftRect.right().
Corner rectangles only have to influence height of the left/right tile
and width of the top/bottom tile. Width of the left/right tile and
height of the top/bottom tile should not be controlled by corner tiles.
Overall, this is how shadow quads are computed:
* Compute the outer rectangle;
* Compute target rectangle for each corner tile. If some corner tile is
missing, move the target rectangle to the corresponding corner of the
inner shadow rect and set its width and height to 0. We need to do
that to prevent top/right/bottom/left tiles from spanning over
corners:
{F6190219, layout=center, size=full}
We would rather prefer something like this if the top-left tile is
missing:
{F6190233, layout=center, size=full}
* Fix overlaps between corner tiles;
* Compute target rectangles for top, right, bottom, and left tiles;
* Fix overlaps between left/right and top/bottom shadow tiles.
Test Plan:
* Ran tests;
* Resized Konsole to its minimimum size(on X11 and Wayland);
* Opened the calendar popup(on X11 and Wayland):
Before:
{F6190344, layout=center, size=full}
After:
{F6190346, layout=center, size=full}
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: abetts, davidedmundson, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14783
2018-08-12 18:23:12 +00:00
|
|
|
const int width = shadowMargins.left() + std::max(top.width(), bottom.width()) + shadowMargins.right();
|
|
|
|
const int height = shadowMargins.top() + std::max(left.height(), right.height()) + shadowMargins.bottom();
|
[scenes/opengl] Fix overlapping shadow tiles
Summary:
This problem appears if shadow corner tiles are too big and
some window has size smaller than 2 * shadowTileSize.
This change tries to address the problem above by exclusing
overlapping tile parts. If there are any two overlapping corners
then tile between them(top/right/bottom/left) is not rendered.
Also, because some corner tile parts can be excluded, corner tiles
are expected to be symmetrical(i.e. if we remove right half from
the top-left tile and left half from the top-right tile and
stick them together, they still look fine, there are no misalignments, etc).
Most shadows(e.g. shadows from Breeze) have such behaviour.
No tiles are overlapping
{F5728514, layout=center, size=full}
Overlapping tiles
{F5728516, layout=center, size=full}
And this is how it supposed to be
{F5728517, layout=center, size=full}
Test Plan:
* apply D11069 to Breeze
* in System Settings/Application Style/Window Decorations, choose "Very Large" shadow size
* open Konsole
* resize it to a minimum possible size
Reviewers: #kwin, graesslin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, ngraham, anemeth, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D10811
2018-06-07 08:48:05 +00:00
|
|
|
|
[scenes/opengl] Correctly draw shadows when corner tiles are missing
Summary:
Current implementation of buildQuads assumes that corner shadow tiles
are always present:
const QRectF leftRect(
topLeftRect.bottomLeft(),
bottomLeftRect.topRight());
but that assumption is wrong. For example, if the default panel is on
the bottom screen edge, then the calendar popup won't have the
bottom-left shadow tile(at least on Wayland). Which means that the left
shadow tile won't be visible because
topLeftRect.left() == bottomLeftRect.right().
Corner rectangles only have to influence height of the left/right tile
and width of the top/bottom tile. Width of the left/right tile and
height of the top/bottom tile should not be controlled by corner tiles.
Overall, this is how shadow quads are computed:
* Compute the outer rectangle;
* Compute target rectangle for each corner tile. If some corner tile is
missing, move the target rectangle to the corresponding corner of the
inner shadow rect and set its width and height to 0. We need to do
that to prevent top/right/bottom/left tiles from spanning over
corners:
{F6190219, layout=center, size=full}
We would rather prefer something like this if the top-left tile is
missing:
{F6190233, layout=center, size=full}
* Fix overlaps between corner tiles;
* Compute target rectangles for top, right, bottom, and left tiles;
* Fix overlaps between left/right and top/bottom shadow tiles.
Test Plan:
* Ran tests;
* Resized Konsole to its minimimum size(on X11 and Wayland);
* Opened the calendar popup(on X11 and Wayland):
Before:
{F6190344, layout=center, size=full}
After:
{F6190346, layout=center, size=full}
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: abetts, davidedmundson, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14783
2018-08-12 18:23:12 +00:00
|
|
|
QRectF topLeftRect;
|
|
|
|
if (!topLeft.isEmpty()) {
|
|
|
|
topLeftRect = QRectF(outerRect.topLeft(), topLeft);
|
|
|
|
} else {
|
|
|
|
topLeftRect = QRectF(
|
|
|
|
outerRect.left() + shadowMargins.left(),
|
|
|
|
outerRect.top() + shadowMargins.top(),
|
|
|
|
0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
QRectF topRightRect;
|
|
|
|
if (!topRight.isEmpty()) {
|
|
|
|
topRightRect = QRectF(
|
|
|
|
outerRect.right() - topRight.width(), outerRect.top(),
|
|
|
|
topRight.width(), topRight.height());
|
|
|
|
} else {
|
|
|
|
topRightRect = QRectF(
|
|
|
|
outerRect.right() - shadowMargins.right(),
|
|
|
|
outerRect.top() + shadowMargins.top(),
|
|
|
|
0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
QRectF bottomRightRect;
|
|
|
|
if (!bottomRight.isEmpty()) {
|
|
|
|
bottomRightRect = QRectF(
|
|
|
|
outerRect.right() - bottomRight.width(),
|
|
|
|
outerRect.bottom() - bottomRight.height(),
|
|
|
|
bottomRight.width(), bottomRight.height());
|
|
|
|
} else {
|
|
|
|
bottomRightRect = QRectF(
|
|
|
|
outerRect.right() - shadowMargins.right(),
|
|
|
|
outerRect.bottom() - shadowMargins.bottom(),
|
|
|
|
0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
QRectF bottomLeftRect;
|
|
|
|
if (!bottomLeft.isEmpty()) {
|
|
|
|
bottomLeftRect = QRectF(
|
|
|
|
outerRect.left(), outerRect.bottom() - bottomLeft.height(),
|
|
|
|
bottomLeft.width(), bottomLeft.height());
|
|
|
|
} else {
|
|
|
|
bottomLeftRect = QRectF(
|
|
|
|
outerRect.left() + shadowMargins.left(),
|
|
|
|
outerRect.bottom() - shadowMargins.bottom(),
|
|
|
|
0, 0);
|
|
|
|
}
|
[scenes/opengl] Fix overlapping shadow tiles
Summary:
This problem appears if shadow corner tiles are too big and
some window has size smaller than 2 * shadowTileSize.
This change tries to address the problem above by exclusing
overlapping tile parts. If there are any two overlapping corners
then tile between them(top/right/bottom/left) is not rendered.
Also, because some corner tile parts can be excluded, corner tiles
are expected to be symmetrical(i.e. if we remove right half from
the top-left tile and left half from the top-right tile and
stick them together, they still look fine, there are no misalignments, etc).
Most shadows(e.g. shadows from Breeze) have such behaviour.
No tiles are overlapping
{F5728514, layout=center, size=full}
Overlapping tiles
{F5728516, layout=center, size=full}
And this is how it supposed to be
{F5728517, layout=center, size=full}
Test Plan:
* apply D11069 to Breeze
* in System Settings/Application Style/Window Decorations, choose "Very Large" shadow size
* open Konsole
* resize it to a minimum possible size
Reviewers: #kwin, graesslin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, ngraham, anemeth, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D10811
2018-06-07 08:48:05 +00:00
|
|
|
|
|
|
|
// Re-distribute the corner tiles so no one of them is overlapping with others.
|
|
|
|
// By doing this, we assume that shadow's corner tiles are symmetric
|
|
|
|
// and it is OK to not draw top/right/bottom/left tile between corners.
|
|
|
|
// For example, let's say top-left and top-right tiles are overlapping.
|
|
|
|
// In that case, the right side of the top-left tile will be shifted to left,
|
|
|
|
// the left side of the top-right tile will shifted to right, and the top
|
|
|
|
// tile won't be rendered.
|
[scenes/opengl] Correctly draw shadows when corner tiles are missing
Summary:
Current implementation of buildQuads assumes that corner shadow tiles
are always present:
const QRectF leftRect(
topLeftRect.bottomLeft(),
bottomLeftRect.topRight());
but that assumption is wrong. For example, if the default panel is on
the bottom screen edge, then the calendar popup won't have the
bottom-left shadow tile(at least on Wayland). Which means that the left
shadow tile won't be visible because
topLeftRect.left() == bottomLeftRect.right().
Corner rectangles only have to influence height of the left/right tile
and width of the top/bottom tile. Width of the left/right tile and
height of the top/bottom tile should not be controlled by corner tiles.
Overall, this is how shadow quads are computed:
* Compute the outer rectangle;
* Compute target rectangle for each corner tile. If some corner tile is
missing, move the target rectangle to the corresponding corner of the
inner shadow rect and set its width and height to 0. We need to do
that to prevent top/right/bottom/left tiles from spanning over
corners:
{F6190219, layout=center, size=full}
We would rather prefer something like this if the top-left tile is
missing:
{F6190233, layout=center, size=full}
* Fix overlaps between corner tiles;
* Compute target rectangles for top, right, bottom, and left tiles;
* Fix overlaps between left/right and top/bottom shadow tiles.
Test Plan:
* Ran tests;
* Resized Konsole to its minimimum size(on X11 and Wayland);
* Opened the calendar popup(on X11 and Wayland):
Before:
{F6190344, layout=center, size=full}
After:
{F6190346, layout=center, size=full}
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: abetts, davidedmundson, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14783
2018-08-12 18:23:12 +00:00
|
|
|
distributeHorizontally(topLeftRect, topRightRect);
|
|
|
|
distributeHorizontally(bottomLeftRect, bottomRightRect);
|
|
|
|
distributeVertically(topLeftRect, bottomLeftRect);
|
|
|
|
distributeVertically(topRightRect, bottomRightRect);
|
[scenes/opengl] Fix overlapping shadow tiles
Summary:
This problem appears if shadow corner tiles are too big and
some window has size smaller than 2 * shadowTileSize.
This change tries to address the problem above by exclusing
overlapping tile parts. If there are any two overlapping corners
then tile between them(top/right/bottom/left) is not rendered.
Also, because some corner tile parts can be excluded, corner tiles
are expected to be symmetrical(i.e. if we remove right half from
the top-left tile and left half from the top-right tile and
stick them together, they still look fine, there are no misalignments, etc).
Most shadows(e.g. shadows from Breeze) have such behaviour.
No tiles are overlapping
{F5728514, layout=center, size=full}
Overlapping tiles
{F5728516, layout=center, size=full}
And this is how it supposed to be
{F5728517, layout=center, size=full}
Test Plan:
* apply D11069 to Breeze
* in System Settings/Application Style/Window Decorations, choose "Very Large" shadow size
* open Konsole
* resize it to a minimum possible size
Reviewers: #kwin, graesslin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, ngraham, anemeth, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D10811
2018-06-07 08:48:05 +00:00
|
|
|
|
|
|
|
qreal tx1 = 0.0,
|
|
|
|
tx2 = 0.0,
|
|
|
|
ty1 = 0.0,
|
|
|
|
ty2 = 0.0;
|
2011-11-25 14:03:21 +00:00
|
|
|
|
[scenes/opengl] Fix overlapping shadow tiles
Summary:
This problem appears if shadow corner tiles are too big and
some window has size smaller than 2 * shadowTileSize.
This change tries to address the problem above by exclusing
overlapping tile parts. If there are any two overlapping corners
then tile between them(top/right/bottom/left) is not rendered.
Also, because some corner tile parts can be excluded, corner tiles
are expected to be symmetrical(i.e. if we remove right half from
the top-left tile and left half from the top-right tile and
stick them together, they still look fine, there are no misalignments, etc).
Most shadows(e.g. shadows from Breeze) have such behaviour.
No tiles are overlapping
{F5728514, layout=center, size=full}
Overlapping tiles
{F5728516, layout=center, size=full}
And this is how it supposed to be
{F5728517, layout=center, size=full}
Test Plan:
* apply D11069 to Breeze
* in System Settings/Application Style/Window Decorations, choose "Very Large" shadow size
* open Konsole
* resize it to a minimum possible size
Reviewers: #kwin, graesslin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, ngraham, anemeth, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D10811
2018-06-07 08:48:05 +00:00
|
|
|
m_shadowQuads.clear();
|
2011-11-25 14:03:21 +00:00
|
|
|
|
[scenes/opengl] Correctly draw shadows when corner tiles are missing
Summary:
Current implementation of buildQuads assumes that corner shadow tiles
are always present:
const QRectF leftRect(
topLeftRect.bottomLeft(),
bottomLeftRect.topRight());
but that assumption is wrong. For example, if the default panel is on
the bottom screen edge, then the calendar popup won't have the
bottom-left shadow tile(at least on Wayland). Which means that the left
shadow tile won't be visible because
topLeftRect.left() == bottomLeftRect.right().
Corner rectangles only have to influence height of the left/right tile
and width of the top/bottom tile. Width of the left/right tile and
height of the top/bottom tile should not be controlled by corner tiles.
Overall, this is how shadow quads are computed:
* Compute the outer rectangle;
* Compute target rectangle for each corner tile. If some corner tile is
missing, move the target rectangle to the corresponding corner of the
inner shadow rect and set its width and height to 0. We need to do
that to prevent top/right/bottom/left tiles from spanning over
corners:
{F6190219, layout=center, size=full}
We would rather prefer something like this if the top-left tile is
missing:
{F6190233, layout=center, size=full}
* Fix overlaps between corner tiles;
* Compute target rectangles for top, right, bottom, and left tiles;
* Fix overlaps between left/right and top/bottom shadow tiles.
Test Plan:
* Ran tests;
* Resized Konsole to its minimimum size(on X11 and Wayland);
* Opened the calendar popup(on X11 and Wayland):
Before:
{F6190344, layout=center, size=full}
After:
{F6190346, layout=center, size=full}
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: abetts, davidedmundson, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14783
2018-08-12 18:23:12 +00:00
|
|
|
if (topLeftRect.isValid()) {
|
|
|
|
tx1 = 0.0;
|
|
|
|
ty1 = 0.0;
|
|
|
|
tx2 = topLeftRect.width() / width;
|
|
|
|
ty2 = topLeftRect.height() / height;
|
|
|
|
WindowQuad topLeftQuad(WindowQuadShadow);
|
|
|
|
topLeftQuad[0] = WindowVertex(topLeftRect.left(), topLeftRect.top(), tx1, ty1);
|
|
|
|
topLeftQuad[1] = WindowVertex(topLeftRect.right(), topLeftRect.top(), tx2, ty1);
|
|
|
|
topLeftQuad[2] = WindowVertex(topLeftRect.right(), topLeftRect.bottom(), tx2, ty2);
|
|
|
|
topLeftQuad[3] = WindowVertex(topLeftRect.left(), topLeftRect.bottom(), tx1, ty2);
|
|
|
|
m_shadowQuads.append(topLeftQuad);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (topRightRect.isValid()) {
|
|
|
|
tx1 = 1.0 - topRightRect.width() / width;
|
|
|
|
ty1 = 0.0;
|
|
|
|
tx2 = 1.0;
|
|
|
|
ty2 = topRightRect.height() / height;
|
|
|
|
WindowQuad topRightQuad(WindowQuadShadow);
|
|
|
|
topRightQuad[0] = WindowVertex(topRightRect.left(), topRightRect.top(), tx1, ty1);
|
|
|
|
topRightQuad[1] = WindowVertex(topRightRect.right(), topRightRect.top(), tx2, ty1);
|
|
|
|
topRightQuad[2] = WindowVertex(topRightRect.right(), topRightRect.bottom(), tx2, ty2);
|
|
|
|
topRightQuad[3] = WindowVertex(topRightRect.left(), topRightRect.bottom(), tx1, ty2);
|
|
|
|
m_shadowQuads.append(topRightQuad);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bottomRightRect.isValid()) {
|
|
|
|
tx1 = 1.0 - bottomRightRect.width() / width;
|
|
|
|
tx2 = 1.0;
|
|
|
|
ty1 = 1.0 - bottomRightRect.height() / height;
|
|
|
|
ty2 = 1.0;
|
|
|
|
WindowQuad bottomRightQuad(WindowQuadShadow);
|
|
|
|
bottomRightQuad[0] = WindowVertex(bottomRightRect.left(), bottomRightRect.top(), tx1, ty1);
|
|
|
|
bottomRightQuad[1] = WindowVertex(bottomRightRect.right(), bottomRightRect.top(), tx2, ty1);
|
|
|
|
bottomRightQuad[2] = WindowVertex(bottomRightRect.right(), bottomRightRect.bottom(), tx2, ty2);
|
|
|
|
bottomRightQuad[3] = WindowVertex(bottomRightRect.left(), bottomRightRect.bottom(), tx1, ty2);
|
|
|
|
m_shadowQuads.append(bottomRightQuad);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bottomLeftRect.isValid()) {
|
|
|
|
tx1 = 0.0;
|
|
|
|
tx2 = bottomLeftRect.width() / width;
|
|
|
|
ty1 = 1.0 - bottomLeftRect.height() / height;
|
|
|
|
ty2 = 1.0;
|
|
|
|
WindowQuad bottomLeftQuad(WindowQuadShadow);
|
|
|
|
bottomLeftQuad[0] = WindowVertex(bottomLeftRect.left(), bottomLeftRect.top(), tx1, ty1);
|
|
|
|
bottomLeftQuad[1] = WindowVertex(bottomLeftRect.right(), bottomLeftRect.top(), tx2, ty1);
|
|
|
|
bottomLeftQuad[2] = WindowVertex(bottomLeftRect.right(), bottomLeftRect.bottom(), tx2, ty2);
|
|
|
|
bottomLeftQuad[3] = WindowVertex(bottomLeftRect.left(), bottomLeftRect.bottom(), tx1, ty2);
|
|
|
|
m_shadowQuads.append(bottomLeftQuad);
|
|
|
|
}
|
|
|
|
|
|
|
|
QRectF topRect(
|
|
|
|
QPointF(topLeftRect.right(), outerRect.top()),
|
|
|
|
QPointF(topRightRect.left(), outerRect.top() + top.height()));
|
|
|
|
|
|
|
|
QRectF rightRect(
|
|
|
|
QPointF(outerRect.right() - right.width(), topRightRect.bottom()),
|
|
|
|
QPointF(outerRect.right(), bottomRightRect.top()));
|
|
|
|
|
|
|
|
QRectF bottomRect(
|
|
|
|
QPointF(bottomLeftRect.right(), outerRect.bottom() - bottom.height()),
|
|
|
|
QPointF(bottomRightRect.left(), outerRect.bottom()));
|
|
|
|
|
|
|
|
QRectF leftRect(
|
|
|
|
QPointF(outerRect.left(), topLeftRect.bottom()),
|
|
|
|
QPointF(outerRect.left() + left.width(), bottomLeftRect.top()));
|
|
|
|
|
|
|
|
// Re-distribute left/right and top/bottom shadow tiles so they don't
|
|
|
|
// overlap when the window is too small. Please notice that we don't
|
|
|
|
// fix overlaps between left/top(left/bottom, right/top, and so on)
|
|
|
|
// corner tiles because corresponding counter parts won't be valid when
|
|
|
|
// the window is too small, which means they won't be rendered.
|
|
|
|
distributeHorizontally(leftRect, rightRect);
|
|
|
|
distributeVertically(topRect, bottomRect);
|
|
|
|
|
|
|
|
if (topRect.isValid()) {
|
[scenes/opengl] Fix overlaps in shadow texture atlas
Summary:
If the corner shadow tiles(top-left, top-right, and so on) tiles are missing,
then the left/top/right/bottom shadow tiles will overlap.
This diff addresses that problem by changing how the shadow texture
atlas is rendered:
* corner tiles will be drawn in the corners of the atlas(buildQuads
method expects them to be at the corners);
* top, right, bottom, and left tile will be aligned to the top-left
corner of the inner shadow rect.
For majority of desktop themes, the shadow texture atlas looks the same.
For example, here's for Aether:
Before:
{F6190484, layout=center, size=full}
After:
{F6190488, layout=center, size=full}
Depends on D14783
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14784
2018-08-12 23:52:12 +00:00
|
|
|
tx1 = shadowMargins.left() / width;
|
[scenes/opengl] Fix overlapping shadow tiles
Summary:
This problem appears if shadow corner tiles are too big and
some window has size smaller than 2 * shadowTileSize.
This change tries to address the problem above by exclusing
overlapping tile parts. If there are any two overlapping corners
then tile between them(top/right/bottom/left) is not rendered.
Also, because some corner tile parts can be excluded, corner tiles
are expected to be symmetrical(i.e. if we remove right half from
the top-left tile and left half from the top-right tile and
stick them together, they still look fine, there are no misalignments, etc).
Most shadows(e.g. shadows from Breeze) have such behaviour.
No tiles are overlapping
{F5728514, layout=center, size=full}
Overlapping tiles
{F5728516, layout=center, size=full}
And this is how it supposed to be
{F5728517, layout=center, size=full}
Test Plan:
* apply D11069 to Breeze
* in System Settings/Application Style/Window Decorations, choose "Very Large" shadow size
* open Konsole
* resize it to a minimum possible size
Reviewers: #kwin, graesslin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, ngraham, anemeth, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D10811
2018-06-07 08:48:05 +00:00
|
|
|
ty1 = 0.0;
|
[scenes/opengl] Correctly draw shadows when corner tiles are missing
Summary:
Current implementation of buildQuads assumes that corner shadow tiles
are always present:
const QRectF leftRect(
topLeftRect.bottomLeft(),
bottomLeftRect.topRight());
but that assumption is wrong. For example, if the default panel is on
the bottom screen edge, then the calendar popup won't have the
bottom-left shadow tile(at least on Wayland). Which means that the left
shadow tile won't be visible because
topLeftRect.left() == bottomLeftRect.right().
Corner rectangles only have to influence height of the left/right tile
and width of the top/bottom tile. Width of the left/right tile and
height of the top/bottom tile should not be controlled by corner tiles.
Overall, this is how shadow quads are computed:
* Compute the outer rectangle;
* Compute target rectangle for each corner tile. If some corner tile is
missing, move the target rectangle to the corresponding corner of the
inner shadow rect and set its width and height to 0. We need to do
that to prevent top/right/bottom/left tiles from spanning over
corners:
{F6190219, layout=center, size=full}
We would rather prefer something like this if the top-left tile is
missing:
{F6190233, layout=center, size=full}
* Fix overlaps between corner tiles;
* Compute target rectangles for top, right, bottom, and left tiles;
* Fix overlaps between left/right and top/bottom shadow tiles.
Test Plan:
* Ran tests;
* Resized Konsole to its minimimum size(on X11 and Wayland);
* Opened the calendar popup(on X11 and Wayland):
Before:
{F6190344, layout=center, size=full}
After:
{F6190346, layout=center, size=full}
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: abetts, davidedmundson, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14783
2018-08-12 18:23:12 +00:00
|
|
|
tx2 = tx1 + top.width() / width;
|
[scenes/opengl] Fix overlapping shadow tiles
Summary:
This problem appears if shadow corner tiles are too big and
some window has size smaller than 2 * shadowTileSize.
This change tries to address the problem above by exclusing
overlapping tile parts. If there are any two overlapping corners
then tile between them(top/right/bottom/left) is not rendered.
Also, because some corner tile parts can be excluded, corner tiles
are expected to be symmetrical(i.e. if we remove right half from
the top-left tile and left half from the top-right tile and
stick them together, they still look fine, there are no misalignments, etc).
Most shadows(e.g. shadows from Breeze) have such behaviour.
No tiles are overlapping
{F5728514, layout=center, size=full}
Overlapping tiles
{F5728516, layout=center, size=full}
And this is how it supposed to be
{F5728517, layout=center, size=full}
Test Plan:
* apply D11069 to Breeze
* in System Settings/Application Style/Window Decorations, choose "Very Large" shadow size
* open Konsole
* resize it to a minimum possible size
Reviewers: #kwin, graesslin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, ngraham, anemeth, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D10811
2018-06-07 08:48:05 +00:00
|
|
|
ty2 = topRect.height() / height;
|
|
|
|
WindowQuad topQuad(WindowQuadShadow);
|
|
|
|
topQuad[0] = WindowVertex(topRect.left(), topRect.top(), tx1, ty1);
|
|
|
|
topQuad[1] = WindowVertex(topRect.right(), topRect.top(), tx2, ty1);
|
|
|
|
topQuad[2] = WindowVertex(topRect.right(), topRect.bottom(), tx2, ty2);
|
|
|
|
topQuad[3] = WindowVertex(topRect.left(), topRect.bottom(), tx1, ty2);
|
|
|
|
m_shadowQuads.append(topQuad);
|
|
|
|
}
|
|
|
|
|
[scenes/opengl] Correctly draw shadows when corner tiles are missing
Summary:
Current implementation of buildQuads assumes that corner shadow tiles
are always present:
const QRectF leftRect(
topLeftRect.bottomLeft(),
bottomLeftRect.topRight());
but that assumption is wrong. For example, if the default panel is on
the bottom screen edge, then the calendar popup won't have the
bottom-left shadow tile(at least on Wayland). Which means that the left
shadow tile won't be visible because
topLeftRect.left() == bottomLeftRect.right().
Corner rectangles only have to influence height of the left/right tile
and width of the top/bottom tile. Width of the left/right tile and
height of the top/bottom tile should not be controlled by corner tiles.
Overall, this is how shadow quads are computed:
* Compute the outer rectangle;
* Compute target rectangle for each corner tile. If some corner tile is
missing, move the target rectangle to the corresponding corner of the
inner shadow rect and set its width and height to 0. We need to do
that to prevent top/right/bottom/left tiles from spanning over
corners:
{F6190219, layout=center, size=full}
We would rather prefer something like this if the top-left tile is
missing:
{F6190233, layout=center, size=full}
* Fix overlaps between corner tiles;
* Compute target rectangles for top, right, bottom, and left tiles;
* Fix overlaps between left/right and top/bottom shadow tiles.
Test Plan:
* Ran tests;
* Resized Konsole to its minimimum size(on X11 and Wayland);
* Opened the calendar popup(on X11 and Wayland):
Before:
{F6190344, layout=center, size=full}
After:
{F6190346, layout=center, size=full}
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: abetts, davidedmundson, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14783
2018-08-12 18:23:12 +00:00
|
|
|
if (rightRect.isValid()) {
|
[scenes/opengl] Fix overlapping shadow tiles
Summary:
This problem appears if shadow corner tiles are too big and
some window has size smaller than 2 * shadowTileSize.
This change tries to address the problem above by exclusing
overlapping tile parts. If there are any two overlapping corners
then tile between them(top/right/bottom/left) is not rendered.
Also, because some corner tile parts can be excluded, corner tiles
are expected to be symmetrical(i.e. if we remove right half from
the top-left tile and left half from the top-right tile and
stick them together, they still look fine, there are no misalignments, etc).
Most shadows(e.g. shadows from Breeze) have such behaviour.
No tiles are overlapping
{F5728514, layout=center, size=full}
Overlapping tiles
{F5728516, layout=center, size=full}
And this is how it supposed to be
{F5728517, layout=center, size=full}
Test Plan:
* apply D11069 to Breeze
* in System Settings/Application Style/Window Decorations, choose "Very Large" shadow size
* open Konsole
* resize it to a minimum possible size
Reviewers: #kwin, graesslin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, ngraham, anemeth, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D10811
2018-06-07 08:48:05 +00:00
|
|
|
tx1 = 1.0 - rightRect.width() / width;
|
[scenes/opengl] Fix overlaps in shadow texture atlas
Summary:
If the corner shadow tiles(top-left, top-right, and so on) tiles are missing,
then the left/top/right/bottom shadow tiles will overlap.
This diff addresses that problem by changing how the shadow texture
atlas is rendered:
* corner tiles will be drawn in the corners of the atlas(buildQuads
method expects them to be at the corners);
* top, right, bottom, and left tile will be aligned to the top-left
corner of the inner shadow rect.
For majority of desktop themes, the shadow texture atlas looks the same.
For example, here's for Aether:
Before:
{F6190484, layout=center, size=full}
After:
{F6190488, layout=center, size=full}
Depends on D14783
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14784
2018-08-12 23:52:12 +00:00
|
|
|
ty1 = shadowMargins.top() / height;
|
[scenes/opengl] Fix overlapping shadow tiles
Summary:
This problem appears if shadow corner tiles are too big and
some window has size smaller than 2 * shadowTileSize.
This change tries to address the problem above by exclusing
overlapping tile parts. If there are any two overlapping corners
then tile between them(top/right/bottom/left) is not rendered.
Also, because some corner tile parts can be excluded, corner tiles
are expected to be symmetrical(i.e. if we remove right half from
the top-left tile and left half from the top-right tile and
stick them together, they still look fine, there are no misalignments, etc).
Most shadows(e.g. shadows from Breeze) have such behaviour.
No tiles are overlapping
{F5728514, layout=center, size=full}
Overlapping tiles
{F5728516, layout=center, size=full}
And this is how it supposed to be
{F5728517, layout=center, size=full}
Test Plan:
* apply D11069 to Breeze
* in System Settings/Application Style/Window Decorations, choose "Very Large" shadow size
* open Konsole
* resize it to a minimum possible size
Reviewers: #kwin, graesslin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, ngraham, anemeth, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D10811
2018-06-07 08:48:05 +00:00
|
|
|
tx2 = 1.0;
|
[scenes/opengl] Correctly draw shadows when corner tiles are missing
Summary:
Current implementation of buildQuads assumes that corner shadow tiles
are always present:
const QRectF leftRect(
topLeftRect.bottomLeft(),
bottomLeftRect.topRight());
but that assumption is wrong. For example, if the default panel is on
the bottom screen edge, then the calendar popup won't have the
bottom-left shadow tile(at least on Wayland). Which means that the left
shadow tile won't be visible because
topLeftRect.left() == bottomLeftRect.right().
Corner rectangles only have to influence height of the left/right tile
and width of the top/bottom tile. Width of the left/right tile and
height of the top/bottom tile should not be controlled by corner tiles.
Overall, this is how shadow quads are computed:
* Compute the outer rectangle;
* Compute target rectangle for each corner tile. If some corner tile is
missing, move the target rectangle to the corresponding corner of the
inner shadow rect and set its width and height to 0. We need to do
that to prevent top/right/bottom/left tiles from spanning over
corners:
{F6190219, layout=center, size=full}
We would rather prefer something like this if the top-left tile is
missing:
{F6190233, layout=center, size=full}
* Fix overlaps between corner tiles;
* Compute target rectangles for top, right, bottom, and left tiles;
* Fix overlaps between left/right and top/bottom shadow tiles.
Test Plan:
* Ran tests;
* Resized Konsole to its minimimum size(on X11 and Wayland);
* Opened the calendar popup(on X11 and Wayland):
Before:
{F6190344, layout=center, size=full}
After:
{F6190346, layout=center, size=full}
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: abetts, davidedmundson, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14783
2018-08-12 18:23:12 +00:00
|
|
|
ty2 = ty1 + right.height() / height;
|
[scenes/opengl] Fix overlapping shadow tiles
Summary:
This problem appears if shadow corner tiles are too big and
some window has size smaller than 2 * shadowTileSize.
This change tries to address the problem above by exclusing
overlapping tile parts. If there are any two overlapping corners
then tile between them(top/right/bottom/left) is not rendered.
Also, because some corner tile parts can be excluded, corner tiles
are expected to be symmetrical(i.e. if we remove right half from
the top-left tile and left half from the top-right tile and
stick them together, they still look fine, there are no misalignments, etc).
Most shadows(e.g. shadows from Breeze) have such behaviour.
No tiles are overlapping
{F5728514, layout=center, size=full}
Overlapping tiles
{F5728516, layout=center, size=full}
And this is how it supposed to be
{F5728517, layout=center, size=full}
Test Plan:
* apply D11069 to Breeze
* in System Settings/Application Style/Window Decorations, choose "Very Large" shadow size
* open Konsole
* resize it to a minimum possible size
Reviewers: #kwin, graesslin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, ngraham, anemeth, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D10811
2018-06-07 08:48:05 +00:00
|
|
|
WindowQuad rightQuad(WindowQuadShadow);
|
|
|
|
rightQuad[0] = WindowVertex(rightRect.left(), rightRect.top(), tx1, ty1);
|
|
|
|
rightQuad[1] = WindowVertex(rightRect.right(), rightRect.top(), tx2, ty1);
|
|
|
|
rightQuad[2] = WindowVertex(rightRect.right(), rightRect.bottom(), tx2, ty2);
|
|
|
|
rightQuad[3] = WindowVertex(rightRect.left(), rightRect.bottom(), tx1, ty2);
|
|
|
|
m_shadowQuads.append(rightQuad);
|
|
|
|
}
|
|
|
|
|
[scenes/opengl] Correctly draw shadows when corner tiles are missing
Summary:
Current implementation of buildQuads assumes that corner shadow tiles
are always present:
const QRectF leftRect(
topLeftRect.bottomLeft(),
bottomLeftRect.topRight());
but that assumption is wrong. For example, if the default panel is on
the bottom screen edge, then the calendar popup won't have the
bottom-left shadow tile(at least on Wayland). Which means that the left
shadow tile won't be visible because
topLeftRect.left() == bottomLeftRect.right().
Corner rectangles only have to influence height of the left/right tile
and width of the top/bottom tile. Width of the left/right tile and
height of the top/bottom tile should not be controlled by corner tiles.
Overall, this is how shadow quads are computed:
* Compute the outer rectangle;
* Compute target rectangle for each corner tile. If some corner tile is
missing, move the target rectangle to the corresponding corner of the
inner shadow rect and set its width and height to 0. We need to do
that to prevent top/right/bottom/left tiles from spanning over
corners:
{F6190219, layout=center, size=full}
We would rather prefer something like this if the top-left tile is
missing:
{F6190233, layout=center, size=full}
* Fix overlaps between corner tiles;
* Compute target rectangles for top, right, bottom, and left tiles;
* Fix overlaps between left/right and top/bottom shadow tiles.
Test Plan:
* Ran tests;
* Resized Konsole to its minimimum size(on X11 and Wayland);
* Opened the calendar popup(on X11 and Wayland):
Before:
{F6190344, layout=center, size=full}
After:
{F6190346, layout=center, size=full}
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: abetts, davidedmundson, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14783
2018-08-12 18:23:12 +00:00
|
|
|
if (bottomRect.isValid()) {
|
[scenes/opengl] Fix overlaps in shadow texture atlas
Summary:
If the corner shadow tiles(top-left, top-right, and so on) tiles are missing,
then the left/top/right/bottom shadow tiles will overlap.
This diff addresses that problem by changing how the shadow texture
atlas is rendered:
* corner tiles will be drawn in the corners of the atlas(buildQuads
method expects them to be at the corners);
* top, right, bottom, and left tile will be aligned to the top-left
corner of the inner shadow rect.
For majority of desktop themes, the shadow texture atlas looks the same.
For example, here's for Aether:
Before:
{F6190484, layout=center, size=full}
After:
{F6190488, layout=center, size=full}
Depends on D14783
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14784
2018-08-12 23:52:12 +00:00
|
|
|
tx1 = shadowMargins.left() / width;
|
[scenes/opengl] Fix overlapping shadow tiles
Summary:
This problem appears if shadow corner tiles are too big and
some window has size smaller than 2 * shadowTileSize.
This change tries to address the problem above by exclusing
overlapping tile parts. If there are any two overlapping corners
then tile between them(top/right/bottom/left) is not rendered.
Also, because some corner tile parts can be excluded, corner tiles
are expected to be symmetrical(i.e. if we remove right half from
the top-left tile and left half from the top-right tile and
stick them together, they still look fine, there are no misalignments, etc).
Most shadows(e.g. shadows from Breeze) have such behaviour.
No tiles are overlapping
{F5728514, layout=center, size=full}
Overlapping tiles
{F5728516, layout=center, size=full}
And this is how it supposed to be
{F5728517, layout=center, size=full}
Test Plan:
* apply D11069 to Breeze
* in System Settings/Application Style/Window Decorations, choose "Very Large" shadow size
* open Konsole
* resize it to a minimum possible size
Reviewers: #kwin, graesslin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, ngraham, anemeth, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D10811
2018-06-07 08:48:05 +00:00
|
|
|
ty1 = 1.0 - bottomRect.height() / height;
|
[scenes/opengl] Correctly draw shadows when corner tiles are missing
Summary:
Current implementation of buildQuads assumes that corner shadow tiles
are always present:
const QRectF leftRect(
topLeftRect.bottomLeft(),
bottomLeftRect.topRight());
but that assumption is wrong. For example, if the default panel is on
the bottom screen edge, then the calendar popup won't have the
bottom-left shadow tile(at least on Wayland). Which means that the left
shadow tile won't be visible because
topLeftRect.left() == bottomLeftRect.right().
Corner rectangles only have to influence height of the left/right tile
and width of the top/bottom tile. Width of the left/right tile and
height of the top/bottom tile should not be controlled by corner tiles.
Overall, this is how shadow quads are computed:
* Compute the outer rectangle;
* Compute target rectangle for each corner tile. If some corner tile is
missing, move the target rectangle to the corresponding corner of the
inner shadow rect and set its width and height to 0. We need to do
that to prevent top/right/bottom/left tiles from spanning over
corners:
{F6190219, layout=center, size=full}
We would rather prefer something like this if the top-left tile is
missing:
{F6190233, layout=center, size=full}
* Fix overlaps between corner tiles;
* Compute target rectangles for top, right, bottom, and left tiles;
* Fix overlaps between left/right and top/bottom shadow tiles.
Test Plan:
* Ran tests;
* Resized Konsole to its minimimum size(on X11 and Wayland);
* Opened the calendar popup(on X11 and Wayland):
Before:
{F6190344, layout=center, size=full}
After:
{F6190346, layout=center, size=full}
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: abetts, davidedmundson, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14783
2018-08-12 18:23:12 +00:00
|
|
|
tx2 = tx1 + bottom.width() / width;
|
[scenes/opengl] Fix overlapping shadow tiles
Summary:
This problem appears if shadow corner tiles are too big and
some window has size smaller than 2 * shadowTileSize.
This change tries to address the problem above by exclusing
overlapping tile parts. If there are any two overlapping corners
then tile between them(top/right/bottom/left) is not rendered.
Also, because some corner tile parts can be excluded, corner tiles
are expected to be symmetrical(i.e. if we remove right half from
the top-left tile and left half from the top-right tile and
stick them together, they still look fine, there are no misalignments, etc).
Most shadows(e.g. shadows from Breeze) have such behaviour.
No tiles are overlapping
{F5728514, layout=center, size=full}
Overlapping tiles
{F5728516, layout=center, size=full}
And this is how it supposed to be
{F5728517, layout=center, size=full}
Test Plan:
* apply D11069 to Breeze
* in System Settings/Application Style/Window Decorations, choose "Very Large" shadow size
* open Konsole
* resize it to a minimum possible size
Reviewers: #kwin, graesslin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, ngraham, anemeth, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D10811
2018-06-07 08:48:05 +00:00
|
|
|
ty2 = 1.0;
|
|
|
|
WindowQuad bottomQuad(WindowQuadShadow);
|
|
|
|
bottomQuad[0] = WindowVertex(bottomRect.left(), bottomRect.top(), tx1, ty1);
|
|
|
|
bottomQuad[1] = WindowVertex(bottomRect.right(), bottomRect.top(), tx2, ty1);
|
|
|
|
bottomQuad[2] = WindowVertex(bottomRect.right(), bottomRect.bottom(), tx2, ty2);
|
|
|
|
bottomQuad[3] = WindowVertex(bottomRect.left(), bottomRect.bottom(), tx1, ty2);
|
|
|
|
m_shadowQuads.append(bottomQuad);
|
|
|
|
}
|
|
|
|
|
[scenes/opengl] Correctly draw shadows when corner tiles are missing
Summary:
Current implementation of buildQuads assumes that corner shadow tiles
are always present:
const QRectF leftRect(
topLeftRect.bottomLeft(),
bottomLeftRect.topRight());
but that assumption is wrong. For example, if the default panel is on
the bottom screen edge, then the calendar popup won't have the
bottom-left shadow tile(at least on Wayland). Which means that the left
shadow tile won't be visible because
topLeftRect.left() == bottomLeftRect.right().
Corner rectangles only have to influence height of the left/right tile
and width of the top/bottom tile. Width of the left/right tile and
height of the top/bottom tile should not be controlled by corner tiles.
Overall, this is how shadow quads are computed:
* Compute the outer rectangle;
* Compute target rectangle for each corner tile. If some corner tile is
missing, move the target rectangle to the corresponding corner of the
inner shadow rect and set its width and height to 0. We need to do
that to prevent top/right/bottom/left tiles from spanning over
corners:
{F6190219, layout=center, size=full}
We would rather prefer something like this if the top-left tile is
missing:
{F6190233, layout=center, size=full}
* Fix overlaps between corner tiles;
* Compute target rectangles for top, right, bottom, and left tiles;
* Fix overlaps between left/right and top/bottom shadow tiles.
Test Plan:
* Ran tests;
* Resized Konsole to its minimimum size(on X11 and Wayland);
* Opened the calendar popup(on X11 and Wayland):
Before:
{F6190344, layout=center, size=full}
After:
{F6190346, layout=center, size=full}
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: abetts, davidedmundson, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14783
2018-08-12 18:23:12 +00:00
|
|
|
if (leftRect.isValid()) {
|
[scenes/opengl] Fix overlapping shadow tiles
Summary:
This problem appears if shadow corner tiles are too big and
some window has size smaller than 2 * shadowTileSize.
This change tries to address the problem above by exclusing
overlapping tile parts. If there are any two overlapping corners
then tile between them(top/right/bottom/left) is not rendered.
Also, because some corner tile parts can be excluded, corner tiles
are expected to be symmetrical(i.e. if we remove right half from
the top-left tile and left half from the top-right tile and
stick them together, they still look fine, there are no misalignments, etc).
Most shadows(e.g. shadows from Breeze) have such behaviour.
No tiles are overlapping
{F5728514, layout=center, size=full}
Overlapping tiles
{F5728516, layout=center, size=full}
And this is how it supposed to be
{F5728517, layout=center, size=full}
Test Plan:
* apply D11069 to Breeze
* in System Settings/Application Style/Window Decorations, choose "Very Large" shadow size
* open Konsole
* resize it to a minimum possible size
Reviewers: #kwin, graesslin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, ngraham, anemeth, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D10811
2018-06-07 08:48:05 +00:00
|
|
|
tx1 = 0.0;
|
[scenes/opengl] Fix overlaps in shadow texture atlas
Summary:
If the corner shadow tiles(top-left, top-right, and so on) tiles are missing,
then the left/top/right/bottom shadow tiles will overlap.
This diff addresses that problem by changing how the shadow texture
atlas is rendered:
* corner tiles will be drawn in the corners of the atlas(buildQuads
method expects them to be at the corners);
* top, right, bottom, and left tile will be aligned to the top-left
corner of the inner shadow rect.
For majority of desktop themes, the shadow texture atlas looks the same.
For example, here's for Aether:
Before:
{F6190484, layout=center, size=full}
After:
{F6190488, layout=center, size=full}
Depends on D14783
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14784
2018-08-12 23:52:12 +00:00
|
|
|
ty1 = shadowMargins.top() / height;
|
[scenes/opengl] Fix overlapping shadow tiles
Summary:
This problem appears if shadow corner tiles are too big and
some window has size smaller than 2 * shadowTileSize.
This change tries to address the problem above by exclusing
overlapping tile parts. If there are any two overlapping corners
then tile between them(top/right/bottom/left) is not rendered.
Also, because some corner tile parts can be excluded, corner tiles
are expected to be symmetrical(i.e. if we remove right half from
the top-left tile and left half from the top-right tile and
stick them together, they still look fine, there are no misalignments, etc).
Most shadows(e.g. shadows from Breeze) have such behaviour.
No tiles are overlapping
{F5728514, layout=center, size=full}
Overlapping tiles
{F5728516, layout=center, size=full}
And this is how it supposed to be
{F5728517, layout=center, size=full}
Test Plan:
* apply D11069 to Breeze
* in System Settings/Application Style/Window Decorations, choose "Very Large" shadow size
* open Konsole
* resize it to a minimum possible size
Reviewers: #kwin, graesslin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, ngraham, anemeth, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D10811
2018-06-07 08:48:05 +00:00
|
|
|
tx2 = leftRect.width() / width;
|
[scenes/opengl] Correctly draw shadows when corner tiles are missing
Summary:
Current implementation of buildQuads assumes that corner shadow tiles
are always present:
const QRectF leftRect(
topLeftRect.bottomLeft(),
bottomLeftRect.topRight());
but that assumption is wrong. For example, if the default panel is on
the bottom screen edge, then the calendar popup won't have the
bottom-left shadow tile(at least on Wayland). Which means that the left
shadow tile won't be visible because
topLeftRect.left() == bottomLeftRect.right().
Corner rectangles only have to influence height of the left/right tile
and width of the top/bottom tile. Width of the left/right tile and
height of the top/bottom tile should not be controlled by corner tiles.
Overall, this is how shadow quads are computed:
* Compute the outer rectangle;
* Compute target rectangle for each corner tile. If some corner tile is
missing, move the target rectangle to the corresponding corner of the
inner shadow rect and set its width and height to 0. We need to do
that to prevent top/right/bottom/left tiles from spanning over
corners:
{F6190219, layout=center, size=full}
We would rather prefer something like this if the top-left tile is
missing:
{F6190233, layout=center, size=full}
* Fix overlaps between corner tiles;
* Compute target rectangles for top, right, bottom, and left tiles;
* Fix overlaps between left/right and top/bottom shadow tiles.
Test Plan:
* Ran tests;
* Resized Konsole to its minimimum size(on X11 and Wayland);
* Opened the calendar popup(on X11 and Wayland):
Before:
{F6190344, layout=center, size=full}
After:
{F6190346, layout=center, size=full}
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: abetts, davidedmundson, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14783
2018-08-12 18:23:12 +00:00
|
|
|
ty2 = ty1 + left.height() / height;
|
[scenes/opengl] Fix overlapping shadow tiles
Summary:
This problem appears if shadow corner tiles are too big and
some window has size smaller than 2 * shadowTileSize.
This change tries to address the problem above by exclusing
overlapping tile parts. If there are any two overlapping corners
then tile between them(top/right/bottom/left) is not rendered.
Also, because some corner tile parts can be excluded, corner tiles
are expected to be symmetrical(i.e. if we remove right half from
the top-left tile and left half from the top-right tile and
stick them together, they still look fine, there are no misalignments, etc).
Most shadows(e.g. shadows from Breeze) have such behaviour.
No tiles are overlapping
{F5728514, layout=center, size=full}
Overlapping tiles
{F5728516, layout=center, size=full}
And this is how it supposed to be
{F5728517, layout=center, size=full}
Test Plan:
* apply D11069 to Breeze
* in System Settings/Application Style/Window Decorations, choose "Very Large" shadow size
* open Konsole
* resize it to a minimum possible size
Reviewers: #kwin, graesslin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, ngraham, anemeth, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D10811
2018-06-07 08:48:05 +00:00
|
|
|
WindowQuad leftQuad(WindowQuadShadow);
|
|
|
|
leftQuad[0] = WindowVertex(leftRect.left(), leftRect.top(), tx1, ty1);
|
|
|
|
leftQuad[1] = WindowVertex(leftRect.right(), leftRect.top(), tx2, ty1);
|
|
|
|
leftQuad[2] = WindowVertex(leftRect.right(), leftRect.bottom(), tx2, ty2);
|
|
|
|
leftQuad[3] = WindowVertex(leftRect.left(), leftRect.bottom(), tx1, ty2);
|
|
|
|
m_shadowQuads.append(leftQuad);
|
|
|
|
}
|
2011-06-23 17:06:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool SceneOpenGLShadow::prepareBackend()
|
|
|
|
{
|
2014-07-24 06:39:25 +00:00
|
|
|
if (hasDecorationShadow()) {
|
|
|
|
// simplifies a lot by going directly to
|
2018-12-02 11:59:45 +00:00
|
|
|
Scene *scene = Compositor::self()->scene();
|
|
|
|
scene->makeOpenGLContextCurrent();
|
2014-12-04 09:36:19 +00:00
|
|
|
m_texture = DecorationShadowTextureCache::instance().getTexture(this);
|
2014-07-24 06:39:25 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2011-11-25 14:03:21 +00:00
|
|
|
const QSize top(shadowPixmap(ShadowElementTop).size());
|
|
|
|
const QSize topRight(shadowPixmap(ShadowElementTopRight).size());
|
|
|
|
const QSize right(shadowPixmap(ShadowElementRight).size());
|
|
|
|
const QSize bottom(shadowPixmap(ShadowElementBottom).size());
|
|
|
|
const QSize bottomLeft(shadowPixmap(ShadowElementBottomLeft).size());
|
|
|
|
const QSize left(shadowPixmap(ShadowElementLeft).size());
|
|
|
|
const QSize topLeft(shadowPixmap(ShadowElementTopLeft).size());
|
2016-06-07 13:53:39 +00:00
|
|
|
const QSize bottomRight(shadowPixmap(ShadowElementBottomRight).size());
|
|
|
|
|
Make shadows work for windows 100% width or height
Summary:
Clients provide shadows as 9 images, which then get split into relevant quads.
To work out the full width we need the size of an item on the left, the middle and the right.
Some elements can be legitiamtely missing so to work out the width of the left edge we need to consider
all 3 of topleft,left,bottomleft.
Currently we checked both corners in case one was missing, but it's legitimate for both to be missing if the shadow
stretches the whole way.
BUG: 380825
Test Plan: Shadow on panel, rest looks the same
Reviewers: #plasma, mart
Reviewed By: #plasma, mart
Subscribers: graesslin, mart, plasma-devel, kwin, #kwin
Tags: #plasma
Differential Revision: https://phabricator.kde.org/D6164
2017-06-20 14:48:41 +00:00
|
|
|
const int width = std::max({topLeft.width(), left.width(), bottomLeft.width()}) +
|
|
|
|
std::max(top.width(), bottom.width()) +
|
|
|
|
std::max({topRight.width(), right.width(), bottomRight.width()});
|
|
|
|
const int height = std::max({topLeft.height(), top.height(), topRight.height()}) +
|
|
|
|
std::max(left.height(), right.height()) +
|
|
|
|
std::max({bottomLeft.height(), bottom.height(), bottomRight.height()});
|
2011-06-23 17:06:12 +00:00
|
|
|
|
2016-06-07 12:17:51 +00:00
|
|
|
if (width == 0 || height == 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-06-23 17:06:12 +00:00
|
|
|
QImage image(width, height, QImage::Format_ARGB32);
|
|
|
|
image.fill(Qt::transparent);
|
[scenes/opengl] Fix overlaps in shadow texture atlas
Summary:
If the corner shadow tiles(top-left, top-right, and so on) tiles are missing,
then the left/top/right/bottom shadow tiles will overlap.
This diff addresses that problem by changing how the shadow texture
atlas is rendered:
* corner tiles will be drawn in the corners of the atlas(buildQuads
method expects them to be at the corners);
* top, right, bottom, and left tile will be aligned to the top-left
corner of the inner shadow rect.
For majority of desktop themes, the shadow texture atlas looks the same.
For example, here's for Aether:
Before:
{F6190484, layout=center, size=full}
After:
{F6190488, layout=center, size=full}
Depends on D14783
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14784
2018-08-12 23:52:12 +00:00
|
|
|
|
|
|
|
const int innerRectTop = std::max({topLeft.height(), top.height(), topRight.height()});
|
|
|
|
const int innerRectLeft = std::max({topLeft.width(), left.width(), bottomLeft.width()});
|
|
|
|
|
2011-06-23 17:06:12 +00:00
|
|
|
QPainter p;
|
|
|
|
p.begin(&image);
|
[scenes/opengl] Fix overlaps in shadow texture atlas
Summary:
If the corner shadow tiles(top-left, top-right, and so on) tiles are missing,
then the left/top/right/bottom shadow tiles will overlap.
This diff addresses that problem by changing how the shadow texture
atlas is rendered:
* corner tiles will be drawn in the corners of the atlas(buildQuads
method expects them to be at the corners);
* top, right, bottom, and left tile will be aligned to the top-left
corner of the inner shadow rect.
For majority of desktop themes, the shadow texture atlas looks the same.
For example, here's for Aether:
Before:
{F6190484, layout=center, size=full}
After:
{F6190488, layout=center, size=full}
Depends on D14783
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14784
2018-08-12 23:52:12 +00:00
|
|
|
|
2020-07-12 00:04:56 +00:00
|
|
|
p.drawPixmap(0, 0, topLeft.width(), topLeft.height(), shadowPixmap(ShadowElementTopLeft));
|
|
|
|
p.drawPixmap(innerRectLeft, 0, top.width(), top.height(), shadowPixmap(ShadowElementTop));
|
|
|
|
p.drawPixmap(width - topRight.width(), 0, topRight.width(), topRight.height(), shadowPixmap(ShadowElementTopRight));
|
[scenes/opengl] Fix overlaps in shadow texture atlas
Summary:
If the corner shadow tiles(top-left, top-right, and so on) tiles are missing,
then the left/top/right/bottom shadow tiles will overlap.
This diff addresses that problem by changing how the shadow texture
atlas is rendered:
* corner tiles will be drawn in the corners of the atlas(buildQuads
method expects them to be at the corners);
* top, right, bottom, and left tile will be aligned to the top-left
corner of the inner shadow rect.
For majority of desktop themes, the shadow texture atlas looks the same.
For example, here's for Aether:
Before:
{F6190484, layout=center, size=full}
After:
{F6190488, layout=center, size=full}
Depends on D14783
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14784
2018-08-12 23:52:12 +00:00
|
|
|
|
2020-07-12 00:04:56 +00:00
|
|
|
p.drawPixmap(0, innerRectTop, left.width(), left.height(), shadowPixmap(ShadowElementLeft));
|
|
|
|
p.drawPixmap(width - right.width(), innerRectTop, right.width(), right.height(), shadowPixmap(ShadowElementRight));
|
[scenes/opengl] Fix overlaps in shadow texture atlas
Summary:
If the corner shadow tiles(top-left, top-right, and so on) tiles are missing,
then the left/top/right/bottom shadow tiles will overlap.
This diff addresses that problem by changing how the shadow texture
atlas is rendered:
* corner tiles will be drawn in the corners of the atlas(buildQuads
method expects them to be at the corners);
* top, right, bottom, and left tile will be aligned to the top-left
corner of the inner shadow rect.
For majority of desktop themes, the shadow texture atlas looks the same.
For example, here's for Aether:
Before:
{F6190484, layout=center, size=full}
After:
{F6190488, layout=center, size=full}
Depends on D14783
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, abetts, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D14784
2018-08-12 23:52:12 +00:00
|
|
|
|
2020-07-12 00:04:56 +00:00
|
|
|
p.drawPixmap(0, height - bottomLeft.height(), bottomLeft.width(), bottomLeft.height(), shadowPixmap(ShadowElementBottomLeft));
|
|
|
|
p.drawPixmap(innerRectLeft, height - bottom.height(), bottom.width(), bottom.height(), shadowPixmap(ShadowElementBottom));
|
|
|
|
p.drawPixmap(width - bottomRight.width(), height - bottomRight.height(), bottomRight.width(), bottomRight.height(), shadowPixmap(ShadowElementBottomRight));
|
2020-11-27 19:57:24 +00:00
|
|
|
|
2011-06-23 17:06:12 +00:00
|
|
|
p.end();
|
|
|
|
|
2014-12-13 13:43:56 +00:00
|
|
|
// Check if the image is alpha-only in practice, and if so convert it to an 8-bpp format
|
2015-02-18 08:06:37 +00:00
|
|
|
if (!GLPlatform::instance()->isGLES() && GLTexture::supportsSwizzle() && GLTexture::supportsFormatRG()) {
|
2014-12-13 13:43:56 +00:00
|
|
|
QImage alphaImage(image.size(), QImage::Format_Indexed8); // Change to Format_Alpha8 w/ Qt 5.5
|
|
|
|
bool alphaOnly = true;
|
|
|
|
|
|
|
|
for (ptrdiff_t y = 0; alphaOnly && y < image.height(); y++) {
|
|
|
|
const uint32_t * const src = reinterpret_cast<const uint32_t *>(image.scanLine(y));
|
|
|
|
uint8_t * const dst = reinterpret_cast<uint8_t *>(alphaImage.scanLine(y));
|
|
|
|
|
|
|
|
for (ptrdiff_t x = 0; x < image.width(); x++) {
|
|
|
|
if (src[x] & 0x00ffffff)
|
|
|
|
alphaOnly = false;
|
|
|
|
|
|
|
|
dst[x] = qAlpha(src[x]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (alphaOnly) {
|
|
|
|
image = alphaImage;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-02 11:59:45 +00:00
|
|
|
Scene *scene = Compositor::self()->scene();
|
|
|
|
scene->makeOpenGLContextCurrent();
|
2014-12-04 09:36:19 +00:00
|
|
|
m_texture = QSharedPointer<GLTexture>::create(image);
|
2011-11-25 14:03:21 +00:00
|
|
|
|
2014-12-13 13:43:56 +00:00
|
|
|
if (m_texture->internalFormat() == GL_R8) {
|
|
|
|
// Swizzle red to alpha and all other channels to zero
|
|
|
|
m_texture->bind();
|
|
|
|
m_texture->setSwizzle(GL_ZERO, GL_ZERO, GL_ZERO, GL_RED);
|
|
|
|
}
|
|
|
|
|
2011-06-23 17:06:12 +00:00
|
|
|
return true;
|
2011-03-27 10:33:07 +00:00
|
|
|
}
|
|
|
|
|
2014-07-22 11:11:19 +00:00
|
|
|
SceneOpenGLDecorationRenderer::SceneOpenGLDecorationRenderer(Decoration::DecoratedClientImpl *client)
|
|
|
|
: Renderer(client)
|
|
|
|
, m_texture()
|
|
|
|
{
|
2015-12-03 16:12:25 +00:00
|
|
|
connect(this, &Renderer::renderScheduled, client->client(), static_cast<void (AbstractClient::*)(const QRect&)>(&AbstractClient::addRepaint));
|
2014-07-22 11:11:19 +00:00
|
|
|
}
|
|
|
|
|
2019-02-10 21:37:06 +00:00
|
|
|
SceneOpenGLDecorationRenderer::~SceneOpenGLDecorationRenderer()
|
|
|
|
{
|
|
|
|
if (Scene *scene = Compositor::self()->scene()) {
|
|
|
|
scene->makeOpenGLContextCurrent();
|
|
|
|
}
|
|
|
|
}
|
2014-07-22 11:11:19 +00:00
|
|
|
|
|
|
|
// Rotates the given source rect 90° counter-clockwise,
|
|
|
|
// and flips it vertically
|
|
|
|
static QImage rotate(const QImage &srcImage, const QRect &srcRect)
|
|
|
|
{
|
2017-11-01 17:54:21 +00:00
|
|
|
auto dpr = srcImage.devicePixelRatio();
|
|
|
|
QImage image(srcRect.height() * dpr, srcRect.width() * dpr, srcImage.format());
|
|
|
|
image.setDevicePixelRatio(dpr);
|
|
|
|
const QPoint srcPoint(srcRect.x() * dpr, srcRect.y() * dpr);
|
2014-07-22 11:11:19 +00:00
|
|
|
|
|
|
|
const uint32_t *src = reinterpret_cast<const uint32_t *>(srcImage.bits());
|
|
|
|
uint32_t *dst = reinterpret_cast<uint32_t *>(image.bits());
|
|
|
|
|
|
|
|
for (int x = 0; x < image.width(); x++) {
|
2017-11-01 17:54:21 +00:00
|
|
|
const uint32_t *s = src + (srcPoint.y() + x) * srcImage.width() + srcPoint.x();
|
2014-07-22 11:11:19 +00:00
|
|
|
uint32_t *d = dst + x;
|
|
|
|
|
|
|
|
for (int y = 0; y < image.height(); y++) {
|
|
|
|
*d = s[y];
|
|
|
|
d += image.width();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return image;
|
|
|
|
}
|
|
|
|
|
[scene] Fix decoration texture bleeding
Summary:
Quite long time ago, window decorations were painted on real X11 windows.
The nicest thing about that approach is that we get both contents of the
client and the frame window at the same time. However, somewhere around
KDE 4.2 - 4.3 times, decoration rendering architecture had been changed
to what we have now.
I've mentioned the previous decoration rendering design because it didn't
have a problem that the new design has, namely the texture bleeding issue.
In the name of better performance, opengl scene puts all decoration parts
to an atlas. This is totally reasonable, however we must be super cautious
about things such as the GL_LINEAR filter.
The GL_LINEAR filter may need to sample a couple of neighboring texels
in order to produce the final texel value. However, since all decoration
parts now live in a single texture, we have to make sure that we don't
sample texels that belong to another decoration part.
This patch fixes the texture bleeding problem by padding each individual
decoration part in the atlas. There is another solution for this problem
though. We could render a window into an offscreen texture and then map
that texture on the transformed window geometry. This would work well and
we definitely need an offscreen rendering path in the opengl scene,
however it's not feasible at the moment since we need to break the window
quads API. Also, it would be great to have as less as possible stuff going
on between invocation of Scene::Window::performPaint() and getting the
corresponding pixel data on the screen.
There is a good chance that the new padding stuff may make you vomit. If
it does so, I'm all ears for the suggestions how to make the code more
nicer.
BUG: 257566
BUG: 360549
CCBUG: 412573
FIXED-IN: 5.18.0
Reviewers: #kwin
Subscribers: fredrik, kwin, fvogt
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D25611
2019-11-28 12:00:58 +00:00
|
|
|
static void clamp_row(int left, int width, int right, const uint32_t *src, uint32_t *dest)
|
|
|
|
{
|
|
|
|
std::fill_n(dest, left, *src);
|
|
|
|
std::copy(src, src + width, dest + left);
|
|
|
|
std::fill_n(dest + left + width, right, *(src + width - 1));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void clamp_sides(int left, int width, int right, const uint32_t *src, uint32_t *dest)
|
|
|
|
{
|
|
|
|
std::fill_n(dest, left, *src);
|
|
|
|
std::fill_n(dest + left + width, right, *(src + width - 1));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void clamp(QImage &image, const QRect &viewport)
|
|
|
|
{
|
|
|
|
Q_ASSERT(image.depth() == 32);
|
|
|
|
|
|
|
|
const QRect rect = image.rect();
|
|
|
|
|
|
|
|
const int left = viewport.left() - rect.left();
|
|
|
|
const int top = viewport.top() - rect.top();
|
|
|
|
const int right = rect.right() - viewport.right();
|
|
|
|
const int bottom = rect.bottom() - viewport.bottom();
|
|
|
|
|
|
|
|
const int width = rect.width() - left - right;
|
|
|
|
const int height = rect.height() - top - bottom;
|
|
|
|
|
|
|
|
const uint32_t *firstRow = reinterpret_cast<uint32_t *>(image.scanLine(top));
|
|
|
|
const uint32_t *lastRow = reinterpret_cast<uint32_t *>(image.scanLine(top + height - 1));
|
|
|
|
|
|
|
|
for (int i = 0; i < top; ++i) {
|
|
|
|
uint32_t *dest = reinterpret_cast<uint32_t *>(image.scanLine(i));
|
|
|
|
clamp_row(left, width, right, firstRow + left, dest);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < height; ++i) {
|
|
|
|
uint32_t *dest = reinterpret_cast<uint32_t *>(image.scanLine(top + i));
|
|
|
|
clamp_sides(left, width, right, dest + left, dest);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < bottom; ++i) {
|
|
|
|
uint32_t *dest = reinterpret_cast<uint32_t *>(image.scanLine(top + height + i));
|
|
|
|
clamp_row(left, width, right, lastRow + left, dest);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-22 11:11:19 +00:00
|
|
|
void SceneOpenGLDecorationRenderer::render()
|
|
|
|
{
|
|
|
|
const QRegion scheduled = getScheduled();
|
2020-01-26 13:08:52 +00:00
|
|
|
if (scheduled.isEmpty()) {
|
2014-07-22 11:11:19 +00:00
|
|
|
return;
|
|
|
|
}
|
2020-01-26 13:08:52 +00:00
|
|
|
if (areImageSizesDirty()) {
|
2014-07-22 11:11:19 +00:00
|
|
|
resizeTexture();
|
|
|
|
resetImageSizesDirty();
|
|
|
|
}
|
|
|
|
|
2016-04-11 07:42:22 +00:00
|
|
|
if (!m_texture) {
|
|
|
|
// for invalid sizes we get no texture, see BUG 361551
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-07-22 11:11:19 +00:00
|
|
|
QRect left, top, right, bottom;
|
2014-07-25 10:55:28 +00:00
|
|
|
client()->client()->layoutDecorationRects(left, top, right, bottom);
|
2014-07-22 11:11:19 +00:00
|
|
|
|
[scene] Fix decoration texture bleeding
Summary:
Quite long time ago, window decorations were painted on real X11 windows.
The nicest thing about that approach is that we get both contents of the
client and the frame window at the same time. However, somewhere around
KDE 4.2 - 4.3 times, decoration rendering architecture had been changed
to what we have now.
I've mentioned the previous decoration rendering design because it didn't
have a problem that the new design has, namely the texture bleeding issue.
In the name of better performance, opengl scene puts all decoration parts
to an atlas. This is totally reasonable, however we must be super cautious
about things such as the GL_LINEAR filter.
The GL_LINEAR filter may need to sample a couple of neighboring texels
in order to produce the final texel value. However, since all decoration
parts now live in a single texture, we have to make sure that we don't
sample texels that belong to another decoration part.
This patch fixes the texture bleeding problem by padding each individual
decoration part in the atlas. There is another solution for this problem
though. We could render a window into an offscreen texture and then map
that texture on the transformed window geometry. This would work well and
we definitely need an offscreen rendering path in the opengl scene,
however it's not feasible at the moment since we need to break the window
quads API. Also, it would be great to have as less as possible stuff going
on between invocation of Scene::Window::performPaint() and getting the
corresponding pixel data on the screen.
There is a good chance that the new padding stuff may make you vomit. If
it does so, I'm all ears for the suggestions how to make the code more
nicer.
BUG: 257566
BUG: 360549
CCBUG: 412573
FIXED-IN: 5.18.0
Reviewers: #kwin
Subscribers: fredrik, kwin, fvogt
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D25611
2019-11-28 12:00:58 +00:00
|
|
|
// We pad each part in the decoration atlas in order to avoid texture bleeding.
|
|
|
|
const int padding = 1;
|
|
|
|
|
|
|
|
auto renderPart = [=](const QRect &geo, const QRect &partRect, const QPoint &position, bool rotated = false) {
|
2019-07-20 13:13:58 +00:00
|
|
|
if (!geo.isValid()) {
|
2014-07-22 11:11:19 +00:00
|
|
|
return;
|
|
|
|
}
|
[scene] Fix decoration texture bleeding
Summary:
Quite long time ago, window decorations were painted on real X11 windows.
The nicest thing about that approach is that we get both contents of the
client and the frame window at the same time. However, somewhere around
KDE 4.2 - 4.3 times, decoration rendering architecture had been changed
to what we have now.
I've mentioned the previous decoration rendering design because it didn't
have a problem that the new design has, namely the texture bleeding issue.
In the name of better performance, opengl scene puts all decoration parts
to an atlas. This is totally reasonable, however we must be super cautious
about things such as the GL_LINEAR filter.
The GL_LINEAR filter may need to sample a couple of neighboring texels
in order to produce the final texel value. However, since all decoration
parts now live in a single texture, we have to make sure that we don't
sample texels that belong to another decoration part.
This patch fixes the texture bleeding problem by padding each individual
decoration part in the atlas. There is another solution for this problem
though. We could render a window into an offscreen texture and then map
that texture on the transformed window geometry. This would work well and
we definitely need an offscreen rendering path in the opengl scene,
however it's not feasible at the moment since we need to break the window
quads API. Also, it would be great to have as less as possible stuff going
on between invocation of Scene::Window::performPaint() and getting the
corresponding pixel data on the screen.
There is a good chance that the new padding stuff may make you vomit. If
it does so, I'm all ears for the suggestions how to make the code more
nicer.
BUG: 257566
BUG: 360549
CCBUG: 412573
FIXED-IN: 5.18.0
Reviewers: #kwin
Subscribers: fredrik, kwin, fvogt
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D25611
2019-11-28 12:00:58 +00:00
|
|
|
|
|
|
|
QRect rect = geo;
|
|
|
|
|
|
|
|
// We allow partial decoration updates and it might just so happen that the dirty region
|
|
|
|
// is completely contained inside the decoration part, i.e. the dirty region doesn't touch
|
|
|
|
// any of the decoration's edges. In that case, we should **not** pad the dirty region.
|
|
|
|
if (rect.left() == partRect.left()) {
|
|
|
|
rect.setLeft(rect.left() - padding);
|
|
|
|
}
|
|
|
|
if (rect.top() == partRect.top()) {
|
|
|
|
rect.setTop(rect.top() - padding);
|
|
|
|
}
|
|
|
|
if (rect.right() == partRect.right()) {
|
|
|
|
rect.setRight(rect.right() + padding);
|
|
|
|
}
|
|
|
|
if (rect.bottom() == partRect.bottom()) {
|
|
|
|
rect.setBottom(rect.bottom() + padding);
|
|
|
|
}
|
|
|
|
|
|
|
|
QRect viewport = geo.translated(-rect.x(), -rect.y());
|
|
|
|
const qreal devicePixelRatio = client()->client()->screenScale();
|
|
|
|
|
|
|
|
QImage image(rect.size() * devicePixelRatio, QImage::Format_ARGB32_Premultiplied);
|
|
|
|
image.setDevicePixelRatio(devicePixelRatio);
|
|
|
|
image.fill(Qt::transparent);
|
|
|
|
|
|
|
|
QPainter painter(&image);
|
|
|
|
painter.setRenderHint(QPainter::Antialiasing);
|
|
|
|
painter.setViewport(QRect(viewport.topLeft(), viewport.size() * devicePixelRatio));
|
|
|
|
painter.setWindow(QRect(geo.topLeft(), geo.size() * devicePixelRatio));
|
|
|
|
painter.setClipRect(geo);
|
|
|
|
renderToPainter(&painter, geo);
|
|
|
|
painter.end();
|
|
|
|
|
|
|
|
clamp(image, QRect(viewport.topLeft(), viewport.size() * devicePixelRatio));
|
|
|
|
|
2014-07-22 11:11:19 +00:00
|
|
|
if (rotated) {
|
|
|
|
// TODO: get this done directly when rendering to the image
|
[scene] Fix decoration texture bleeding
Summary:
Quite long time ago, window decorations were painted on real X11 windows.
The nicest thing about that approach is that we get both contents of the
client and the frame window at the same time. However, somewhere around
KDE 4.2 - 4.3 times, decoration rendering architecture had been changed
to what we have now.
I've mentioned the previous decoration rendering design because it didn't
have a problem that the new design has, namely the texture bleeding issue.
In the name of better performance, opengl scene puts all decoration parts
to an atlas. This is totally reasonable, however we must be super cautious
about things such as the GL_LINEAR filter.
The GL_LINEAR filter may need to sample a couple of neighboring texels
in order to produce the final texel value. However, since all decoration
parts now live in a single texture, we have to make sure that we don't
sample texels that belong to another decoration part.
This patch fixes the texture bleeding problem by padding each individual
decoration part in the atlas. There is another solution for this problem
though. We could render a window into an offscreen texture and then map
that texture on the transformed window geometry. This would work well and
we definitely need an offscreen rendering path in the opengl scene,
however it's not feasible at the moment since we need to break the window
quads API. Also, it would be great to have as less as possible stuff going
on between invocation of Scene::Window::performPaint() and getting the
corresponding pixel data on the screen.
There is a good chance that the new padding stuff may make you vomit. If
it does so, I'm all ears for the suggestions how to make the code more
nicer.
BUG: 257566
BUG: 360549
CCBUG: 412573
FIXED-IN: 5.18.0
Reviewers: #kwin
Subscribers: fredrik, kwin, fvogt
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D25611
2019-11-28 12:00:58 +00:00
|
|
|
image = rotate(image, QRect(QPoint(), rect.size()));
|
|
|
|
viewport = QRect(viewport.y(), viewport.x(), viewport.height(), viewport.width());
|
2014-07-22 11:11:19 +00:00
|
|
|
}
|
[scene] Fix decoration texture bleeding
Summary:
Quite long time ago, window decorations were painted on real X11 windows.
The nicest thing about that approach is that we get both contents of the
client and the frame window at the same time. However, somewhere around
KDE 4.2 - 4.3 times, decoration rendering architecture had been changed
to what we have now.
I've mentioned the previous decoration rendering design because it didn't
have a problem that the new design has, namely the texture bleeding issue.
In the name of better performance, opengl scene puts all decoration parts
to an atlas. This is totally reasonable, however we must be super cautious
about things such as the GL_LINEAR filter.
The GL_LINEAR filter may need to sample a couple of neighboring texels
in order to produce the final texel value. However, since all decoration
parts now live in a single texture, we have to make sure that we don't
sample texels that belong to another decoration part.
This patch fixes the texture bleeding problem by padding each individual
decoration part in the atlas. There is another solution for this problem
though. We could render a window into an offscreen texture and then map
that texture on the transformed window geometry. This would work well and
we definitely need an offscreen rendering path in the opengl scene,
however it's not feasible at the moment since we need to break the window
quads API. Also, it would be great to have as less as possible stuff going
on between invocation of Scene::Window::performPaint() and getting the
corresponding pixel data on the screen.
There is a good chance that the new padding stuff may make you vomit. If
it does so, I'm all ears for the suggestions how to make the code more
nicer.
BUG: 257566
BUG: 360549
CCBUG: 412573
FIXED-IN: 5.18.0
Reviewers: #kwin
Subscribers: fredrik, kwin, fvogt
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D25611
2019-11-28 12:00:58 +00:00
|
|
|
|
|
|
|
const QPoint dirtyOffset = geo.topLeft() - partRect.topLeft();
|
|
|
|
m_texture->update(image, (position + dirtyOffset - viewport.topLeft()) * image.devicePixelRatio());
|
2014-07-22 11:11:19 +00:00
|
|
|
};
|
[scene] Fix decoration texture bleeding
Summary:
Quite long time ago, window decorations were painted on real X11 windows.
The nicest thing about that approach is that we get both contents of the
client and the frame window at the same time. However, somewhere around
KDE 4.2 - 4.3 times, decoration rendering architecture had been changed
to what we have now.
I've mentioned the previous decoration rendering design because it didn't
have a problem that the new design has, namely the texture bleeding issue.
In the name of better performance, opengl scene puts all decoration parts
to an atlas. This is totally reasonable, however we must be super cautious
about things such as the GL_LINEAR filter.
The GL_LINEAR filter may need to sample a couple of neighboring texels
in order to produce the final texel value. However, since all decoration
parts now live in a single texture, we have to make sure that we don't
sample texels that belong to another decoration part.
This patch fixes the texture bleeding problem by padding each individual
decoration part in the atlas. There is another solution for this problem
though. We could render a window into an offscreen texture and then map
that texture on the transformed window geometry. This would work well and
we definitely need an offscreen rendering path in the opengl scene,
however it's not feasible at the moment since we need to break the window
quads API. Also, it would be great to have as less as possible stuff going
on between invocation of Scene::Window::performPaint() and getting the
corresponding pixel data on the screen.
There is a good chance that the new padding stuff may make you vomit. If
it does so, I'm all ears for the suggestions how to make the code more
nicer.
BUG: 257566
BUG: 360549
CCBUG: 412573
FIXED-IN: 5.18.0
Reviewers: #kwin
Subscribers: fredrik, kwin, fvogt
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D25611
2019-11-28 12:00:58 +00:00
|
|
|
|
2020-01-26 13:08:52 +00:00
|
|
|
const QRect geometry = scheduled.boundingRect();
|
|
|
|
|
[scene] Fix decoration texture bleeding
Summary:
Quite long time ago, window decorations were painted on real X11 windows.
The nicest thing about that approach is that we get both contents of the
client and the frame window at the same time. However, somewhere around
KDE 4.2 - 4.3 times, decoration rendering architecture had been changed
to what we have now.
I've mentioned the previous decoration rendering design because it didn't
have a problem that the new design has, namely the texture bleeding issue.
In the name of better performance, opengl scene puts all decoration parts
to an atlas. This is totally reasonable, however we must be super cautious
about things such as the GL_LINEAR filter.
The GL_LINEAR filter may need to sample a couple of neighboring texels
in order to produce the final texel value. However, since all decoration
parts now live in a single texture, we have to make sure that we don't
sample texels that belong to another decoration part.
This patch fixes the texture bleeding problem by padding each individual
decoration part in the atlas. There is another solution for this problem
though. We could render a window into an offscreen texture and then map
that texture on the transformed window geometry. This would work well and
we definitely need an offscreen rendering path in the opengl scene,
however it's not feasible at the moment since we need to break the window
quads API. Also, it would be great to have as less as possible stuff going
on between invocation of Scene::Window::performPaint() and getting the
corresponding pixel data on the screen.
There is a good chance that the new padding stuff may make you vomit. If
it does so, I'm all ears for the suggestions how to make the code more
nicer.
BUG: 257566
BUG: 360549
CCBUG: 412573
FIXED-IN: 5.18.0
Reviewers: #kwin
Subscribers: fredrik, kwin, fvogt
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D25611
2019-11-28 12:00:58 +00:00
|
|
|
const QPoint topPosition(padding, padding);
|
|
|
|
const QPoint bottomPosition(padding, topPosition.y() + top.height() + 2 * padding);
|
|
|
|
const QPoint leftPosition(padding, bottomPosition.y() + bottom.height() + 2 * padding);
|
|
|
|
const QPoint rightPosition(padding, leftPosition.y() + left.width() + 2 * padding);
|
|
|
|
|
|
|
|
renderPart(left.intersected(geometry), left, leftPosition, true);
|
|
|
|
renderPart(top.intersected(geometry), top, topPosition);
|
|
|
|
renderPart(right.intersected(geometry), right, rightPosition, true);
|
|
|
|
renderPart(bottom.intersected(geometry), bottom, bottomPosition);
|
2014-07-22 11:11:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int align(int value, int align)
|
|
|
|
{
|
|
|
|
return (value + align - 1) & ~(align - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SceneOpenGLDecorationRenderer::resizeTexture()
|
|
|
|
{
|
|
|
|
QRect left, top, right, bottom;
|
2014-07-25 10:55:28 +00:00
|
|
|
client()->client()->layoutDecorationRects(left, top, right, bottom);
|
2014-07-22 11:11:19 +00:00
|
|
|
QSize size;
|
|
|
|
|
|
|
|
size.rwidth() = qMax(qMax(top.width(), bottom.width()),
|
|
|
|
qMax(left.height(), right.height()));
|
|
|
|
size.rheight() = top.height() + bottom.height() +
|
[scene] Fix decoration texture bleeding
Summary:
Quite long time ago, window decorations were painted on real X11 windows.
The nicest thing about that approach is that we get both contents of the
client and the frame window at the same time. However, somewhere around
KDE 4.2 - 4.3 times, decoration rendering architecture had been changed
to what we have now.
I've mentioned the previous decoration rendering design because it didn't
have a problem that the new design has, namely the texture bleeding issue.
In the name of better performance, opengl scene puts all decoration parts
to an atlas. This is totally reasonable, however we must be super cautious
about things such as the GL_LINEAR filter.
The GL_LINEAR filter may need to sample a couple of neighboring texels
in order to produce the final texel value. However, since all decoration
parts now live in a single texture, we have to make sure that we don't
sample texels that belong to another decoration part.
This patch fixes the texture bleeding problem by padding each individual
decoration part in the atlas. There is another solution for this problem
though. We could render a window into an offscreen texture and then map
that texture on the transformed window geometry. This would work well and
we definitely need an offscreen rendering path in the opengl scene,
however it's not feasible at the moment since we need to break the window
quads API. Also, it would be great to have as less as possible stuff going
on between invocation of Scene::Window::performPaint() and getting the
corresponding pixel data on the screen.
There is a good chance that the new padding stuff may make you vomit. If
it does so, I'm all ears for the suggestions how to make the code more
nicer.
BUG: 257566
BUG: 360549
CCBUG: 412573
FIXED-IN: 5.18.0
Reviewers: #kwin
Subscribers: fredrik, kwin, fvogt
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D25611
2019-11-28 12:00:58 +00:00
|
|
|
left.width() + right.width();
|
|
|
|
|
|
|
|
// Reserve some space for padding. We pad decoration parts to avoid texture bleeding.
|
|
|
|
const int padding = 1;
|
|
|
|
size.rwidth() += 2 * padding;
|
|
|
|
size.rheight() += 4 * 2 * padding;
|
2014-07-22 11:11:19 +00:00
|
|
|
|
|
|
|
size.rwidth() = align(size.width(), 128);
|
|
|
|
|
2017-11-01 17:54:21 +00:00
|
|
|
size *= client()->client()->screenScale();
|
2014-07-22 11:11:19 +00:00
|
|
|
if (m_texture && m_texture->size() == size)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!size.isEmpty()) {
|
2014-12-13 13:28:33 +00:00
|
|
|
m_texture.reset(new GLTexture(GL_RGBA8, size.width(), size.height()));
|
2014-07-22 11:11:19 +00:00
|
|
|
m_texture->setYInverted(true);
|
|
|
|
m_texture->setWrapMode(GL_CLAMP_TO_EDGE);
|
|
|
|
m_texture->clear();
|
|
|
|
} else {
|
|
|
|
m_texture.reset();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-23 07:20:28 +00:00
|
|
|
void SceneOpenGLDecorationRenderer::reparent(Deleted *deleted)
|
|
|
|
{
|
|
|
|
render();
|
|
|
|
Renderer::reparent(deleted);
|
|
|
|
}
|
|
|
|
|
2017-09-08 20:30:18 +00:00
|
|
|
|
|
|
|
OpenGLFactory::OpenGLFactory(QObject *parent)
|
|
|
|
: SceneFactory(parent)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
OpenGLFactory::~OpenGLFactory() = default;
|
|
|
|
|
|
|
|
Scene *OpenGLFactory::create(QObject *parent) const
|
|
|
|
{
|
|
|
|
qCDebug(KWIN_OPENGL) << "Initializing OpenGL compositing";
|
|
|
|
|
|
|
|
// Some broken drivers crash on glXQuery() so to prevent constant KWin crashes:
|
|
|
|
if (kwinApp()->platform()->openGLCompositingIsBroken()) {
|
|
|
|
qCWarning(KWIN_OPENGL) << "KWin has detected that your OpenGL library is unsafe to use";
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PreInit);
|
|
|
|
auto s = SceneOpenGL::createScene(parent);
|
|
|
|
kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PostInit);
|
|
|
|
if (s && s->initFailed()) {
|
|
|
|
delete s;
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
} // namespace
|