2020-08-02 22:22:19 +00:00
|
|
|
/*
|
|
|
|
KWin - the KDE window manager
|
|
|
|
This file is part of the KDE project.
|
2017-09-08 20:30:18 +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>
|
2017-09-08 20:30:18 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
*/
|
2021-01-05 19:07:35 +00:00
|
|
|
#include "openglbackend.h"
|
2017-09-08 20:30:18 +00:00
|
|
|
#include <kwineffects.h>
|
|
|
|
#include <logging.h>
|
|
|
|
|
|
|
|
#include "screens.h"
|
|
|
|
|
|
|
|
#include <epoxy/gl.h>
|
|
|
|
|
|
|
|
namespace KWin
|
|
|
|
{
|
|
|
|
|
|
|
|
OpenGLBackend::OpenGLBackend()
|
Introduce RenderLoop
At the moment, our frame scheduling infrastructure is still heavily
based on Xinerama-style rendering. Specifically, we assume that painting
is driven by a single timer, etc.
This change introduces a new type - RenderLoop. Its main purpose is to
drive compositing on a specific output, or in case of X11, on the
overlay window.
With RenderLoop, compositing is synchronized to vblank events. It
exposes the last and the next estimated presentation timestamp. The
expected presentation timestamp can be used by effects to ensure that
animations are synchronized with the upcoming vblank event.
On Wayland, every outputs has its own render loop. On X11, per screen
rendering is not possible, therefore the platform exposes the render
loop for the overlay window. Ideally, the Scene has to expose the
RenderLoop, but as the first step towards better compositing scheduling
it's good as is for the time being.
The RenderLoop tries to minimize the latency by delaying compositing as
close as possible to the next vblank event. One tricky thing about it is
that if compositing is too close to the next vblank event, animations
may become a little bit choppy. However, increasing the latency reduces
the choppiness.
Given that, there is no any "silver bullet" solution for the choppiness
issue, a new option has been added in the Compositing KCM to specify the
amount of latency. By default, it's "Medium," but if a user is not
satisfied with the upstream default, they can tweak it.
2020-11-19 08:52:29 +00:00
|
|
|
: m_directRendering(false)
|
2017-09-08 20:30:18 +00:00
|
|
|
, m_haveBufferAge(false)
|
|
|
|
, m_failed(false)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
OpenGLBackend::~OpenGLBackend()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void OpenGLBackend::setFailed(const QString &reason)
|
|
|
|
{
|
|
|
|
qCWarning(KWIN_OPENGL) << "Creating the OpenGL rendering failed: " << reason;
|
|
|
|
m_failed = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void OpenGLBackend::addToDamageHistory(const QRegion ®ion)
|
|
|
|
{
|
|
|
|
if (m_damageHistory.count() > 10)
|
|
|
|
m_damageHistory.removeLast();
|
|
|
|
|
|
|
|
m_damageHistory.prepend(region);
|
|
|
|
}
|
|
|
|
|
|
|
|
QRegion OpenGLBackend::accumulatedDamageHistory(int bufferAge) const
|
|
|
|
{
|
|
|
|
QRegion region;
|
|
|
|
|
|
|
|
// Note: An age of zero means the buffer contents are undefined
|
|
|
|
if (bufferAge > 0 && bufferAge <= m_damageHistory.count()) {
|
|
|
|
for (int i = 0; i < bufferAge - 1; i++)
|
|
|
|
region |= m_damageHistory[i];
|
|
|
|
} else {
|
|
|
|
const QSize &s = screens()->size();
|
|
|
|
region = QRegion(0, 0, s.width(), s.height());
|
|
|
|
}
|
|
|
|
|
|
|
|
return region;
|
|
|
|
}
|
|
|
|
|
2019-08-07 17:33:20 +00:00
|
|
|
OverlayWindow* OpenGLBackend::overlayWindow() const
|
2017-09-08 20:30:18 +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
|
|
|
return nullptr;
|
2017-09-08 20:30:18 +00:00
|
|
|
}
|
|
|
|
|
2021-02-02 13:26:43 +00:00
|
|
|
bool OpenGLBackend::scanout(int screenId, KWaylandServer::SurfaceInterface *surface)
|
|
|
|
{
|
|
|
|
Q_UNUSED(screenId)
|
|
|
|
Q_UNUSED(surface)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-09-08 20:30:18 +00:00
|
|
|
void OpenGLBackend::copyPixels(const QRegion ®ion)
|
|
|
|
{
|
|
|
|
const int height = screens()->size().height();
|
2019-07-09 20:08:47 +00:00
|
|
|
for (const QRect &r : region) {
|
2017-09-08 20:30:18 +00:00
|
|
|
const int x0 = r.x();
|
|
|
|
const int y0 = height - r.y() - r.height();
|
|
|
|
const int x1 = r.x() + r.width();
|
|
|
|
const int y1 = height - r.y();
|
|
|
|
|
|
|
|
glBlitFramebuffer(x0, y0, x1, y1, x0, y0, x1, y1, GL_COLOR_BUFFER_BIT, GL_NEAREST);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-22 17:22:36 +00:00
|
|
|
QSharedPointer<KWin::GLTexture> OpenGLBackend::textureForOutput(AbstractOutput* output) const
|
|
|
|
{
|
|
|
|
Q_UNUSED(output)
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2020-10-30 07:39:17 +00:00
|
|
|
void OpenGLBackend::aboutToStartPainting(int screenId, const QRegion &damage)
|
2020-04-24 17:11:41 +00:00
|
|
|
{
|
2020-10-30 07:39:17 +00:00
|
|
|
Q_UNUSED(screenId)
|
2020-04-24 17:11:41 +00:00
|
|
|
Q_UNUSED(damage)
|
|
|
|
}
|
|
|
|
|
2021-02-02 13:26:43 +00:00
|
|
|
|
|
|
|
bool OpenGLBackend::directScanoutAllowed(int screen) const
|
|
|
|
{
|
|
|
|
Q_UNUSED(screen);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-09-08 20:30:18 +00:00
|
|
|
}
|