kwin/effects/blur/blur.cpp

819 lines
27 KiB
C++
Raw Normal View History

/*
2020-08-02 22:22:19 +00:00
SPDX-FileCopyrightText: 2010 Fredrik Höglund <fredrik@kde.org>
SPDX-FileCopyrightText: 2011 Philipp Knechtges <philipp-dev@knechtges.com>
SPDX-FileCopyrightText: 2018 Alex Nemeth <alex.nemeth329@gmail.com>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "blur.h"
#include "blurshader.h"
// KConfigSkeleton
#include "blurconfig.h"
#include <QGuiApplication>
#include <QMatrix4x4>
#include <QScreen> // for QGuiApplication
#include <QTime>
Add windowsystem plugin for KWin's qpa Summary: KWindowSystem provides a plugin interface to have platform specific implementations. So far KWin relied on the implementation in KWayland-integration repository. This is something I find unsuited, for the following reasons: * any test in KWin for functionality set through the plugin would fail * it's not clear what's going on where * in worst case some code could deadlock * KWin shouldn't use KWindowSystem and only a small subset is allowed to be used The last point needs some further explanation. KWin internally does not and cannot use KWindowSystem. KWindowSystem (especially KWindowInfo) is exposing information which KWin sets. It's more than weird if KWin asks KWindowSystem for the state of a window it set itself. On X11 it's just slow, on Wayland it can result in roundtrips to KWin itself which is dangerous. But due to using Plasma components we have a few areas where we use KWindowSystem. E.g. a Plasma::Dialog sets a window type, the slide in direction, blur and background contrast. This we want to support and need to support. Other API elements we do not want, like for examples the available windows. KWin internal windows either have direct access to KWin or a scripting interface exposed providing (limited) access - there is just no need to have this in KWindowSystem. To make it more clear what KWin supports as API of KWindowSystem for internal windows this change implements a stripped down version of the kwayland-integration plugin. The main difference is that it does not use KWayland at all, but a QWindow internal side channel. To support this EffectWindow provides an accessor for internalWindow and the three already mentioned effects are adjusted to read from the internal QWindow and it's dynamic properties. This change is a first step for a further refactoring. I plan to split the internal window out of ShellClient into a dedicated class. I think there are nowadays too many special cases. If it moves out there is the question whether we really want to use Wayland for the internal windows or whether this is just historic ballast (after all we used to use qwayland for that in the beginning). As the change could introduce regressions I'm targetting 5.16. Test Plan: new test case for window type, manual testing using Alt+Tab for the effects integration. Sliding popups, blur and contrast worked fine. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18228
2019-01-13 16:50:32 +00:00
#include <QWindow>
#include <cmath> // for ceil()
#include <KWaylandServer/surface_interface.h>
#include <KWaylandServer/blur_interface.h>
#include <KWaylandServer/shadow_interface.h>
#include <KWaylandServer/display.h>
#include <KSharedConfig>
#include <KConfigGroup>
namespace KWin
{
static const QByteArray s_blurAtomName = QByteArrayLiteral("_KDE_NET_WM_BLUR_BEHIND_REGION");
BlurEffect::BlurEffect()
{
initConfig<BlurConfig>();
m_shader = new BlurShader(this);
initBlurStrengthValues();
reconfigure(ReconfigureAll);
// ### Hackish way to announce support.
// Should be included in _NET_SUPPORTED instead.
if (m_shader && m_shader->isValid() && m_renderTargetsValid) {
net_wm_blur_region = effects->announceSupportProperty(s_blurAtomName, this);
KWaylandServer::Display *display = effects->waylandDisplay();
if (display) {
m_blurManager = display->createBlurManager(this);
}
} else {
net_wm_blur_region = 0;
}
connect(effects, &EffectsHandler::windowAdded, this, &BlurEffect::slotWindowAdded);
connect(effects, &EffectsHandler::windowDeleted, this, &BlurEffect::slotWindowDeleted);
connect(effects, &EffectsHandler::propertyNotify, this, &BlurEffect::slotPropertyNotify);
connect(effects, &EffectsHandler::screenGeometryChanged, this, &BlurEffect::slotScreenGeometryChanged);
connect(effects, &EffectsHandler::xcbConnectionChanged, this,
[this] {
if (m_shader && m_shader->isValid() && m_renderTargetsValid) {
net_wm_blur_region = effects->announceSupportProperty(s_blurAtomName, this);
}
}
);
// Fetch the blur regions for all windows
foreach (EffectWindow *window, effects->stackingOrder())
updateBlurRegion(window);
}
BlurEffect::~BlurEffect()
{
deleteFBOs();
}
void BlurEffect::slotScreenGeometryChanged()
{
effects->makeOpenGLContextCurrent();
updateTexture();
// Fetch the blur regions for all windows
foreach (EffectWindow *window, effects->stackingOrder())
updateBlurRegion(window);
effects->doneOpenGLContextCurrent();
}
bool BlurEffect::renderTargetsValid() const
{
return !m_renderTargets.isEmpty() && std::find_if(m_renderTargets.cbegin(), m_renderTargets.cend(),
[](const GLRenderTarget *target) {
return !target->valid();
}) == m_renderTargets.cend();
}
void BlurEffect::deleteFBOs()
{
qDeleteAll(m_renderTargets);
m_renderTargets.clear();
m_renderTextures.clear();
}
void BlurEffect::updateTexture()
{
deleteFBOs();
/* Reserve memory for:
* - The original sized texture (1)
* - The downsized textures (m_downSampleIterations)
* - The helper texture (1)
*/
m_renderTargets.reserve(m_downSampleIterations + 2);
m_renderTextures.reserve(m_downSampleIterations + 2);
GLenum textureFormat = GL_RGBA8;
// Check the color encoding of the default framebuffer
if (!GLPlatform::instance()->isGLES()) {
GLuint prevFbo = 0;
glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, reinterpret_cast<GLint *>(&prevFbo));
if (prevFbo != 0) {
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
}
GLenum colorEncoding = GL_LINEAR;
glGetFramebufferAttachmentParameteriv(GL_DRAW_FRAMEBUFFER, GL_BACK_LEFT,
GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING,
reinterpret_cast<GLint *>(&colorEncoding));
if (prevFbo != 0) {
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, prevFbo);
}
if (colorEncoding == GL_SRGB) {
textureFormat = GL_SRGB8_ALPHA8;
}
}
for (int i = 0; i <= m_downSampleIterations; i++) {
m_renderTextures.append(GLTexture(textureFormat, effects->virtualScreenSize() / (1 << i)));
m_renderTextures.last().setFilter(GL_LINEAR);
m_renderTextures.last().setWrapMode(GL_CLAMP_TO_EDGE);
m_renderTargets.append(new GLRenderTarget(m_renderTextures.last()));
}
// This last set is used as a temporary helper texture
m_renderTextures.append(GLTexture(textureFormat, effects->virtualScreenSize()));
m_renderTextures.last().setFilter(GL_LINEAR);
m_renderTextures.last().setWrapMode(GL_CLAMP_TO_EDGE);
m_renderTargets.append(new GLRenderTarget(m_renderTextures.last()));
m_renderTargetsValid = renderTargetsValid();
// Prepare the stack for the rendering
m_renderTargetStack.clear();
m_renderTargetStack.reserve(m_downSampleIterations * 2);
// Upsample
for (int i = 1; i < m_downSampleIterations; i++) {
m_renderTargetStack.push(m_renderTargets[i]);
}
// Downsample
for (int i = m_downSampleIterations; i > 0; i--) {
m_renderTargetStack.push(m_renderTargets[i]);
}
// Copysample
m_renderTargetStack.push(m_renderTargets[0]);
// Generate the noise helper texture
generateNoiseTexture();
}
void BlurEffect::initBlurStrengthValues()
{
// This function creates an array of blur strength values that are evenly distributed
// The range of the slider on the blur settings UI
int numOfBlurSteps = 15;
int remainingSteps = numOfBlurSteps;
/*
* Explanation for these numbers:
*
* The texture blur amount depends on the downsampling iterations and the offset value.
* By changing the offset we can alter the blur amount without relying on further downsampling.
* But there is a minimum and maximum value of offset per downsample iteration before we
* get artifacts.
*
* The minOffset variable is the minimum offset value for an iteration before we
* get blocky artifacts because of the downsampling.
*
* The maxOffset value is the maximum offset value for an iteration before we
* get diagonal line artifacts because of the nature of the dual kawase blur algorithm.
*
* The expandSize value is the minimum value for an iteration before we reach the end
* of a texture in the shader and sample outside of the area that was copied into the
* texture from the screen.
*/
// {minOffset, maxOffset, expandSize}
blurOffsets.append({1.0, 2.0, 10}); // Down sample size / 2
blurOffsets.append({2.0, 3.0, 20}); // Down sample size / 4
blurOffsets.append({2.0, 5.0, 50}); // Down sample size / 8
blurOffsets.append({3.0, 8.0, 150}); // Down sample size / 16
//blurOffsets.append({5.0, 10.0, 400}); // Down sample size / 32
//blurOffsets.append({7.0, ?.0}); // Down sample size / 64
float offsetSum = 0;
for (int i = 0; i < blurOffsets.size(); i++) {
offsetSum += blurOffsets[i].maxOffset - blurOffsets[i].minOffset;
}
for (int i = 0; i < blurOffsets.size(); i++) {
int iterationNumber = std::ceil((blurOffsets[i].maxOffset - blurOffsets[i].minOffset) / offsetSum * numOfBlurSteps);
remainingSteps -= iterationNumber;
if (remainingSteps < 0) {
iterationNumber += remainingSteps;
}
float offsetDifference = blurOffsets[i].maxOffset - blurOffsets[i].minOffset;
for (int j = 1; j <= iterationNumber; j++) {
// {iteration, offset}
blurStrengthValues.append({i + 1, blurOffsets[i].minOffset + (offsetDifference / iterationNumber) * j});
}
}
}
void BlurEffect::reconfigure(ReconfigureFlags flags)
{
Q_UNUSED(flags)
BlurConfig::self()->read();
int blurStrength = BlurConfig::blurStrength() - 1;
m_downSampleIterations = blurStrengthValues[blurStrength].iteration;
m_offset = blurStrengthValues[blurStrength].offset;
m_expandSize = blurOffsets[m_downSampleIterations - 1].expandSize;
m_noiseStrength = BlurConfig::noiseStrength();
m_scalingFactor = qMax(1.0, QGuiApplication::primaryScreen()->logicalDotsPerInch() / 96.0);
updateTexture();
if (!m_shader || !m_shader->isValid()) {
effects->removeSupportProperty(s_blurAtomName, this);
delete m_blurManager;
m_blurManager = nullptr;
}
// Update all windows for the blur to take effect
effects->addRepaintFull();
}
void BlurEffect::updateBlurRegion(EffectWindow *w) const
{
QRegion region;
QByteArray value;
if (net_wm_blur_region != XCB_ATOM_NONE) {
value = w->readProperty(net_wm_blur_region, XCB_ATOM_CARDINAL, 32);
if (value.size() > 0 && !(value.size() % (4 * sizeof(uint32_t)))) {
const uint32_t *cardinals = reinterpret_cast<const uint32_t*>(value.constData());
for (unsigned int i = 0; i < value.size() / sizeof(uint32_t);) {
int x = cardinals[i++];
int y = cardinals[i++];
int w = cardinals[i++];
int h = cardinals[i++];
region += QRect(x, y, w, h);
}
}
}
KWaylandServer::SurfaceInterface *surf = w->surface();
if (surf && surf->blur()) {
region = surf->blur()->region();
}
Add windowsystem plugin for KWin's qpa Summary: KWindowSystem provides a plugin interface to have platform specific implementations. So far KWin relied on the implementation in KWayland-integration repository. This is something I find unsuited, for the following reasons: * any test in KWin for functionality set through the plugin would fail * it's not clear what's going on where * in worst case some code could deadlock * KWin shouldn't use KWindowSystem and only a small subset is allowed to be used The last point needs some further explanation. KWin internally does not and cannot use KWindowSystem. KWindowSystem (especially KWindowInfo) is exposing information which KWin sets. It's more than weird if KWin asks KWindowSystem for the state of a window it set itself. On X11 it's just slow, on Wayland it can result in roundtrips to KWin itself which is dangerous. But due to using Plasma components we have a few areas where we use KWindowSystem. E.g. a Plasma::Dialog sets a window type, the slide in direction, blur and background contrast. This we want to support and need to support. Other API elements we do not want, like for examples the available windows. KWin internal windows either have direct access to KWin or a scripting interface exposed providing (limited) access - there is just no need to have this in KWindowSystem. To make it more clear what KWin supports as API of KWindowSystem for internal windows this change implements a stripped down version of the kwayland-integration plugin. The main difference is that it does not use KWayland at all, but a QWindow internal side channel. To support this EffectWindow provides an accessor for internalWindow and the three already mentioned effects are adjusted to read from the internal QWindow and it's dynamic properties. This change is a first step for a further refactoring. I plan to split the internal window out of ShellClient into a dedicated class. I think there are nowadays too many special cases. If it moves out there is the question whether we really want to use Wayland for the internal windows or whether this is just historic ballast (after all we used to use qwayland for that in the beginning). As the change could introduce regressions I'm targetting 5.16. Test Plan: new test case for window type, manual testing using Alt+Tab for the effects integration. Sliding popups, blur and contrast worked fine. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18228
2019-01-13 16:50:32 +00:00
if (auto internal = w->internalWindow()) {
const auto property = internal->property("kwin_blur");
if (property.isValid()) {
region = property.value<QRegion>();
}
}
//!value.isNull() full window in X11 case, surf->blur()
//valid, full window in wayland case
if (region.isEmpty() && (!value.isNull() || (surf && surf->blur()))) {
// Set the data to a dummy value.
// This is needed to be able to distinguish between the value not
// being set, and being set to an empty region.
w->setData(WindowBlurBehindRole, 1);
} else
w->setData(WindowBlurBehindRole, region);
}
void BlurEffect::slotWindowAdded(EffectWindow *w)
{
KWaylandServer::SurfaceInterface *surf = w->surface();
if (surf) {
windowBlurChangedConnections[w] = connect(surf, &KWaylandServer::SurfaceInterface::blurChanged, this, [this, w] () {
if (w) {
updateBlurRegion(w);
}
});
}
Add windowsystem plugin for KWin's qpa Summary: KWindowSystem provides a plugin interface to have platform specific implementations. So far KWin relied on the implementation in KWayland-integration repository. This is something I find unsuited, for the following reasons: * any test in KWin for functionality set through the plugin would fail * it's not clear what's going on where * in worst case some code could deadlock * KWin shouldn't use KWindowSystem and only a small subset is allowed to be used The last point needs some further explanation. KWin internally does not and cannot use KWindowSystem. KWindowSystem (especially KWindowInfo) is exposing information which KWin sets. It's more than weird if KWin asks KWindowSystem for the state of a window it set itself. On X11 it's just slow, on Wayland it can result in roundtrips to KWin itself which is dangerous. But due to using Plasma components we have a few areas where we use KWindowSystem. E.g. a Plasma::Dialog sets a window type, the slide in direction, blur and background contrast. This we want to support and need to support. Other API elements we do not want, like for examples the available windows. KWin internal windows either have direct access to KWin or a scripting interface exposed providing (limited) access - there is just no need to have this in KWindowSystem. To make it more clear what KWin supports as API of KWindowSystem for internal windows this change implements a stripped down version of the kwayland-integration plugin. The main difference is that it does not use KWayland at all, but a QWindow internal side channel. To support this EffectWindow provides an accessor for internalWindow and the three already mentioned effects are adjusted to read from the internal QWindow and it's dynamic properties. This change is a first step for a further refactoring. I plan to split the internal window out of ShellClient into a dedicated class. I think there are nowadays too many special cases. If it moves out there is the question whether we really want to use Wayland for the internal windows or whether this is just historic ballast (after all we used to use qwayland for that in the beginning). As the change could introduce regressions I'm targetting 5.16. Test Plan: new test case for window type, manual testing using Alt+Tab for the effects integration. Sliding popups, blur and contrast worked fine. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18228
2019-01-13 16:50:32 +00:00
if (auto internal = w->internalWindow()) {
internal->installEventFilter(this);
}
updateBlurRegion(w);
}
void BlurEffect::slotWindowDeleted(EffectWindow *w)
{
auto it = windowBlurChangedConnections.find(w);
if (it == windowBlurChangedConnections.end()) {
return;
}
disconnect(*it);
windowBlurChangedConnections.erase(it);
}
2011-03-12 18:18:19 +00:00
void BlurEffect::slotPropertyNotify(EffectWindow *w, long atom)
{
if (w && atom == net_wm_blur_region && net_wm_blur_region != XCB_ATOM_NONE) {
updateBlurRegion(w);
}
}
Add windowsystem plugin for KWin's qpa Summary: KWindowSystem provides a plugin interface to have platform specific implementations. So far KWin relied on the implementation in KWayland-integration repository. This is something I find unsuited, for the following reasons: * any test in KWin for functionality set through the plugin would fail * it's not clear what's going on where * in worst case some code could deadlock * KWin shouldn't use KWindowSystem and only a small subset is allowed to be used The last point needs some further explanation. KWin internally does not and cannot use KWindowSystem. KWindowSystem (especially KWindowInfo) is exposing information which KWin sets. It's more than weird if KWin asks KWindowSystem for the state of a window it set itself. On X11 it's just slow, on Wayland it can result in roundtrips to KWin itself which is dangerous. But due to using Plasma components we have a few areas where we use KWindowSystem. E.g. a Plasma::Dialog sets a window type, the slide in direction, blur and background contrast. This we want to support and need to support. Other API elements we do not want, like for examples the available windows. KWin internal windows either have direct access to KWin or a scripting interface exposed providing (limited) access - there is just no need to have this in KWindowSystem. To make it more clear what KWin supports as API of KWindowSystem for internal windows this change implements a stripped down version of the kwayland-integration plugin. The main difference is that it does not use KWayland at all, but a QWindow internal side channel. To support this EffectWindow provides an accessor for internalWindow and the three already mentioned effects are adjusted to read from the internal QWindow and it's dynamic properties. This change is a first step for a further refactoring. I plan to split the internal window out of ShellClient into a dedicated class. I think there are nowadays too many special cases. If it moves out there is the question whether we really want to use Wayland for the internal windows or whether this is just historic ballast (after all we used to use qwayland for that in the beginning). As the change could introduce regressions I'm targetting 5.16. Test Plan: new test case for window type, manual testing using Alt+Tab for the effects integration. Sliding popups, blur and contrast worked fine. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18228
2019-01-13 16:50:32 +00:00
bool BlurEffect::eventFilter(QObject *watched, QEvent *event)
{
auto internal = qobject_cast<QWindow*>(watched);
if (internal && event->type() == QEvent::DynamicPropertyChange) {
QDynamicPropertyChangeEvent *pe = static_cast<QDynamicPropertyChangeEvent*>(event);
if (pe->propertyName() == "kwin_blur") {
if (auto w = effects->findWindow(internal)) {
updateBlurRegion(w);
}
}
}
return false;
}
bool BlurEffect::enabledByDefault()
{
GLPlatform *gl = GLPlatform::instance();
if (gl->isIntel() && gl->chipClass() < SandyBridge)
return false;
if (gl->isSoftwareEmulation()) {
return false;
}
return true;
}
bool BlurEffect::supported()
{
bool supported = effects->isOpenGLCompositing() && GLRenderTarget::supported() && GLRenderTarget::blitSupported();
if (supported) {
int maxTexSize;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTexSize);
const QSize screenSize = effects->virtualScreenSize();
if (screenSize.width() > maxTexSize || screenSize.height() > maxTexSize)
supported = false;
}
return supported;
}
QRect BlurEffect::expand(const QRect &rect) const
{
return rect.adjusted(-m_expandSize, -m_expandSize, m_expandSize, m_expandSize);
}
QRegion BlurEffect::expand(const QRegion &region) const
{
QRegion expanded;
for (const QRect &rect : region) {
2011-01-30 14:34:42 +00:00
expanded += expand(rect);
}
return expanded;
}
QRegion BlurEffect::blurRegion(const EffectWindow *w) const
{
QRegion region;
const QVariant value = w->data(WindowBlurBehindRole);
if (value.isValid()) {
const QRegion appRegion = qvariant_cast<QRegion>(value);
if (!appRegion.isEmpty()) {
if (w->decorationHasAlpha() && effects->decorationSupportsBlurBehind()) {
region = w->shape() & w->rect();
region -= w->decorationInnerRect();
}
region |= appRegion.translated(w->contentsRect().topLeft()) &
w->decorationInnerRect();
} else {
// An empty region means that the blur effect should be enabled
// for the whole window.
region = w->shape() & w->rect();
}
} else if (w->decorationHasAlpha() && effects->decorationSupportsBlurBehind()) {
// If the client hasn't specified a blur region, we'll only enable
// the effect behind the decoration.
region = w->shape() & w->rect();
region -= w->decorationInnerRect();
}
return region;
}
void BlurEffect::uploadRegion(QVector2D *&map, const QRegion &region, const int downSampleIterations)
{
for (int i = 0; i <= downSampleIterations; i++) {
const int divisionRatio = (1 << i);
for (const QRect &r : region) {
const QVector2D topLeft( r.x() / divisionRatio, r.y() / divisionRatio);
const QVector2D topRight( (r.x() + r.width()) / divisionRatio, r.y() / divisionRatio);
const QVector2D bottomLeft( r.x() / divisionRatio, (r.y() + r.height()) / divisionRatio);
const QVector2D bottomRight((r.x() + r.width()) / divisionRatio, (r.y() + r.height()) / divisionRatio);
// First triangle
*(map++) = topRight;
*(map++) = topLeft;
*(map++) = bottomLeft;
// Second triangle
*(map++) = bottomLeft;
*(map++) = bottomRight;
*(map++) = topRight;
}
}
}
void BlurEffect::uploadGeometry(GLVertexBuffer *vbo, const QRegion &blurRegion, const QRegion &windowRegion)
{
const int vertexCount = ((blurRegion.rectCount() * (m_downSampleIterations + 1)) + windowRegion.rectCount()) * 6;
if (!vertexCount)
return;
QVector2D *map = (QVector2D *) vbo->map(vertexCount * sizeof(QVector2D));
uploadRegion(map, blurRegion, m_downSampleIterations);
uploadRegion(map, windowRegion, 0);
vbo->unmap();
const GLVertexAttrib layout[] = {
{ VA_Position, 2, GL_FLOAT, 0 },
{ VA_TexCoord, 2, GL_FLOAT, 0 }
};
vbo->setAttribLayout(layout, 2, sizeof(QVector2D));
}
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 BlurEffect::prePaintScreen(ScreenPrePaintData &data, std::chrono::milliseconds presentTime)
{
m_paintedArea = QRegion();
m_currentBlur = QRegion();
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
effects->prePaintScreen(data, presentTime);
}
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 BlurEffect::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, std::chrono::milliseconds presentTime)
{
// this effect relies on prePaintWindow being called in the bottom to top order
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
effects->prePaintWindow(w, data, presentTime);
if (!w->isPaintingEnabled()) {
return;
}
if (!m_shader || !m_shader->isValid()) {
return;
}
// to blur an area partially we have to shrink the opaque area of a window
QRegion newClip;
const QRegion oldClip = data.clip;
for (const QRect &rect : data.clip) {
newClip |= rect.adjusted(m_expandSize, m_expandSize, -m_expandSize, -m_expandSize);
}
data.clip = newClip;
2011-08-03 06:16:12 +00:00
// we don't have to blur a region we don't see
m_currentBlur -= newClip;
// if we have to paint a non-opaque part of this window that intersects with the
// currently blurred region we have to redraw the whole region
if ((data.paint - oldClip).intersects(m_currentBlur)) {
data.paint |= m_currentBlur;
}
// in case this window has regions to be blurred
const QRect screen = effects->virtualScreenGeometry();
const QRegion blurArea = blurRegion(w).translated(w->pos()) & screen;
const QRegion expandedBlur = (w->isDock() ? blurArea : expand(blurArea)) & screen;
// if this window or a window underneath the blurred area is painted again we have to
// blur everything
if (m_paintedArea.intersects(expandedBlur) || data.paint.intersects(blurArea)) {
data.paint |= expandedBlur;
// we have to check again whether we do not damage a blurred area
// of a window
if (expandedBlur.intersects(m_currentBlur)) {
data.paint |= m_currentBlur;
}
}
m_currentBlur |= expandedBlur;
m_paintedArea -= data.clip;
m_paintedArea |= data.paint;
}
bool BlurEffect::shouldBlur(const EffectWindow *w, int mask, const WindowPaintData &data) const
{
if (!m_renderTargetsValid || !m_shader || !m_shader->isValid())
return false;
if (effects->activeFullScreenEffect() && !w->data(WindowForceBlurRole).toBool())
return false;
if (w->isDesktop())
return false;
bool scaled = !qFuzzyCompare(data.xScale(), 1.0) && !qFuzzyCompare(data.yScale(), 1.0);
bool translated = data.xTranslation() || data.yTranslation();
if ((scaled || (translated || (mask & PAINT_WINDOW_TRANSFORMED))) && !w->data(WindowForceBlurRole).toBool())
return false;
bool blurBehindDecos = effects->decorationsHaveAlpha() &&
effects->decorationSupportsBlurBehind();
if (!w->hasAlpha() && w->opacity() >= 1.0 && !(blurBehindDecos && w->hasDecoration()))
return false;
return true;
}
void BlurEffect::drawWindow(EffectWindow *w, int mask, const QRegion &region, WindowPaintData &data)
{
const QRect screen = GLRenderTarget::virtualScreenGeometry();
if (shouldBlur(w, mask, data)) {
QRegion shape = region & blurRegion(w).translated(w->pos()) & screen;
// let's do the evil parts - someone wants to blur behind a transformed window
const bool translated = data.xTranslation() || data.yTranslation();
const bool scaled = data.xScale() != 1 || data.yScale() != 1;
if (scaled) {
QPoint pt = shape.boundingRect().topLeft();
QRegion scaledShape;
for (QRect r : shape) {
r.moveTo(pt.x() + (r.x() - pt.x()) * data.xScale() + data.xTranslation(),
pt.y() + (r.y() - pt.y()) * data.yScale() + data.yTranslation());
r.setWidth(r.width() * data.xScale());
r.setHeight(r.height() * data.yScale());
scaledShape |= r;
}
shape = scaledShape & region;
//Only translated, not scaled
} else if (translated) {
shape = shape.translated(data.xTranslation(), data.yTranslation());
shape = shape & region;
}
2020-11-27 19:57:24 +00:00
EffectWindow* modal = w->transientFor();
const bool transientForIsDock = (modal ? modal->isDock() : false);
if (!shape.isEmpty()) {
doBlur(shape, screen, data.opacity(), data.screenProjectionMatrix(), w->isDock() || transientForIsDock, w->geometry());
}
}
// Draw the window over the blurred area
effects->drawWindow(w, mask, region, data);
}
void BlurEffect::paintEffectFrame(EffectFrame *frame, const QRegion &region, double opacity, double frameOpacity)
{
const QRect screen = effects->virtualScreenGeometry();
bool valid = m_renderTargetsValid && m_shader && m_shader->isValid();
QRegion shape = frame->geometry().adjusted(-borderSize, -borderSize, borderSize, borderSize) & screen;
if (valid && !shape.isEmpty() && region.intersects(shape.boundingRect()) && frame->style() != EffectFrameNone) {
doBlur(shape, screen, opacity * frameOpacity, frame->screenProjectionMatrix(), false, frame->geometry());
}
effects->paintEffectFrame(frame, region, opacity, frameOpacity);
}
void BlurEffect::generateNoiseTexture()
{
if (m_noiseStrength == 0) {
return;
}
// Init randomness based on time
qsrand((uint)QTime::currentTime().msec());
QImage noiseImage(QSize(256, 256), QImage::Format_Grayscale8);
for (int y = 0; y < noiseImage.height(); y++) {
uint8_t *noiseImageLine = (uint8_t *) noiseImage.scanLine(y);
for (int x = 0; x < noiseImage.width(); x++) {
noiseImageLine[x] = qrand() % m_noiseStrength + (128 - m_noiseStrength / 2);
}
}
// The noise texture looks distorted when not scaled with integer
noiseImage = noiseImage.scaled(noiseImage.size() * m_scalingFactor);
m_noiseTexture = GLTexture(noiseImage);
m_noiseTexture.setFilter(GL_NEAREST);
m_noiseTexture.setWrapMode(GL_REPEAT);
}
void BlurEffect::doBlur(const QRegion& shape, const QRect& screen, const float opacity, const QMatrix4x4 &screenProjection, bool isDock, QRect windowRect)
{
// Blur would not render correctly on a secondary monitor because of wrong coordinates
// BUG: 393723
const int xTranslate = -screen.x();
const int yTranslate = effects->virtualScreenSize().height() - screen.height() - screen.y();
const QRegion expandedBlurRegion = expand(shape) & expand(screen);
const bool useSRGB = m_renderTextures.first().internalFormat() == GL_SRGB8_ALPHA8;
// Upload geometry for the down and upsample iterations
GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
vbo->reset();
uploadGeometry(vbo, expandedBlurRegion.translated(xTranslate, yTranslate), shape);
vbo->bindArrays();
const QRect sourceRect = expandedBlurRegion.boundingRect() & screen;
const QRect destRect = sourceRect.translated(xTranslate, yTranslate);
GLRenderTarget::pushRenderTargets(m_renderTargetStack);
int blurRectCount = expandedBlurRegion.rectCount() * 6;
/*
* If the window is a dock or panel we avoid the "extended blur" effect.
* Extended blur is when windows that are not under the blurred area affect
* the final blur result.
* We want to avoid this on panels, because it looks really weird and ugly
* when maximized windows or windows near the panel affect the dock blur.
*/
if (isDock) {
m_renderTargets.last()->blitFromFramebuffer(sourceRect, destRect);
if (useSRGB) {
glEnable(GL_FRAMEBUFFER_SRGB);
}
copyScreenSampleTexture(vbo, blurRectCount, shape.translated(xTranslate, yTranslate), screenProjection);
} else {
m_renderTargets.first()->blitFromFramebuffer(sourceRect, destRect);
if (useSRGB) {
glEnable(GL_FRAMEBUFFER_SRGB);
}
// Remove the m_renderTargets[0] from the top of the stack that we will not use
GLRenderTarget::popRenderTarget();
}
downSampleTexture(vbo, blurRectCount);
upSampleTexture(vbo, blurRectCount);
// Modulate the blurred texture with the window opacity if the window isn't opaque
if (opacity < 1.0) {
glEnable(GL_BLEND);
#if 1 // bow shape, always above y = x
float o = 1.0f-opacity;
o = 1.0f - o*o;
#else // sigmoid shape, above y = x for x > 0.5, below y = x for x < 0.5
float o = 2.0f*opacity - 1.0f;
o = 0.5f + o / (1.0f + qAbs(o));
#endif
glBlendColor(0, 0, 0, o);
glBlendFunc(GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA);
}
upscaleRenderToScreen(vbo, blurRectCount * (m_downSampleIterations + 1), shape.rectCount() * 6, screenProjection, windowRect.topLeft());
if (useSRGB) {
glDisable(GL_FRAMEBUFFER_SRGB);
}
if (opacity < 1.0) {
glDisable(GL_BLEND);
}
vbo->unbindArrays();
}
void BlurEffect::upscaleRenderToScreen(GLVertexBuffer *vbo, int vboStart, int blurRectCount, QMatrix4x4 screenProjection, QPoint windowPosition)
{
glActiveTexture(GL_TEXTURE0);
m_renderTextures[1].bind();
if (m_noiseStrength > 0) {
m_shader->bind(BlurShader::NoiseSampleType);
m_shader->setTargetTextureSize(m_renderTextures[0].size() * GLRenderTarget::virtualScreenScale());
m_shader->setNoiseTextureSize(m_noiseTexture.size() * GLRenderTarget::virtualScreenScale());
m_shader->setTexturePosition(windowPosition * GLRenderTarget::virtualScreenScale());
glActiveTexture(GL_TEXTURE1);
m_noiseTexture.bind();
} else {
m_shader->bind(BlurShader::UpSampleType);
m_shader->setTargetTextureSize(m_renderTextures[0].size() * GLRenderTarget::virtualScreenScale());
}
m_shader->setOffset(m_offset);
m_shader->setModelViewProjectionMatrix(screenProjection);
//Render to the screen
vbo->draw(GL_TRIANGLES, vboStart, blurRectCount);
glActiveTexture(GL_TEXTURE0);
m_shader->unbind();
}
void BlurEffect::downSampleTexture(GLVertexBuffer *vbo, int blurRectCount)
{
QMatrix4x4 modelViewProjectionMatrix;
m_shader->bind(BlurShader::DownSampleType);
m_shader->setOffset(m_offset);
for (int i = 1; i <= m_downSampleIterations; i++) {
modelViewProjectionMatrix.setToIdentity();
modelViewProjectionMatrix.ortho(0, m_renderTextures[i].width(), m_renderTextures[i].height(), 0 , 0, 65535);
m_shader->setModelViewProjectionMatrix(modelViewProjectionMatrix);
m_shader->setTargetTextureSize(m_renderTextures[i].size());
//Copy the image from this texture
m_renderTextures[i - 1].bind();
vbo->draw(GL_TRIANGLES, blurRectCount * i, blurRectCount);
GLRenderTarget::popRenderTarget();
}
m_shader->unbind();
}
void BlurEffect::upSampleTexture(GLVertexBuffer *vbo, int blurRectCount)
{
QMatrix4x4 modelViewProjectionMatrix;
m_shader->bind(BlurShader::UpSampleType);
m_shader->setOffset(m_offset);
for (int i = m_downSampleIterations - 1; i >= 1; i--) {
modelViewProjectionMatrix.setToIdentity();
modelViewProjectionMatrix.ortho(0, m_renderTextures[i].width(), m_renderTextures[i].height(), 0 , 0, 65535);
m_shader->setModelViewProjectionMatrix(modelViewProjectionMatrix);
m_shader->setTargetTextureSize(m_renderTextures[i].size());
//Copy the image from this texture
m_renderTextures[i + 1].bind();
vbo->draw(GL_TRIANGLES, blurRectCount * i, blurRectCount);
GLRenderTarget::popRenderTarget();
}
m_shader->unbind();
}
void BlurEffect::copyScreenSampleTexture(GLVertexBuffer *vbo, int blurRectCount, QRegion blurShape, QMatrix4x4 screenProjection)
{
m_shader->bind(BlurShader::CopySampleType);
m_shader->setModelViewProjectionMatrix(screenProjection);
m_shader->setTargetTextureSize(effects->virtualScreenSize());
/*
* This '1' sized adjustment is necessary do avoid windows affecting the blur that are
* right next to this window.
*/
m_shader->setBlurRect(blurShape.boundingRect().adjusted(1, 1, -1, -1), effects->virtualScreenSize());
m_renderTextures.last().bind();
vbo->draw(GL_TRIANGLES, 0, blurRectCount);
GLRenderTarget::popRenderTarget();
m_shader->unbind();
}
bool BlurEffect::isActive() const
{
return !effects->isScreenLocked();
}
} // namespace KWin