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
|
|
|
|
*/
|
2017-09-08 20:30:18 +00:00
|
|
|
#ifndef KWIN_SCENE_OPENGL_BACKEND_H
|
|
|
|
#define KWIN_SCENE_OPENGL_BACKEND_H
|
|
|
|
|
|
|
|
#include <QRegion>
|
|
|
|
|
|
|
|
#include <kwin_export.h>
|
|
|
|
|
2021-02-02 13:26:43 +00:00
|
|
|
namespace KWaylandServer
|
|
|
|
{
|
|
|
|
class SurfaceInterface;
|
|
|
|
}
|
|
|
|
|
2017-09-08 20:30:18 +00:00
|
|
|
namespace KWin
|
|
|
|
{
|
2020-07-22 17:22:36 +00:00
|
|
|
class AbstractOutput;
|
2017-09-08 20:30:18 +00:00
|
|
|
class OpenGLBackend;
|
|
|
|
class OverlayWindow;
|
|
|
|
class SceneOpenGL;
|
|
|
|
class SceneOpenGLTexture;
|
|
|
|
class SceneOpenGLTexturePrivate;
|
|
|
|
class WindowPixmap;
|
2020-07-22 17:22:36 +00:00
|
|
|
class GLTexture;
|
2017-09-08 20:30:18 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief The OpenGLBackend creates and holds the OpenGL context and is responsible for Texture from Pixmap.
|
|
|
|
*
|
|
|
|
* The OpenGLBackend is an abstract base class used by the SceneOpenGL to abstract away the differences
|
|
|
|
* between various OpenGL windowing systems such as GLX and EGL.
|
|
|
|
*
|
|
|
|
* A concrete implementation has to create and release the OpenGL context in a way so that the
|
|
|
|
* SceneOpenGL does not have to care about it.
|
|
|
|
*
|
|
|
|
* In addition a major task for this class is to generate the SceneOpenGLTexturePrivate which is
|
|
|
|
* able to perform the texture from pixmap operation in the given backend.
|
|
|
|
*
|
|
|
|
* @author Martin Gräßlin <mgraesslin@kde.org>
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2017-09-08 20:30:18 +00:00
|
|
|
class KWIN_EXPORT OpenGLBackend
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
OpenGLBackend();
|
|
|
|
virtual ~OpenGLBackend();
|
|
|
|
|
|
|
|
virtual void init() = 0;
|
2020-11-09 14:10:03 +00:00
|
|
|
|
2017-09-08 20:30:18 +00:00
|
|
|
virtual void screenGeometryChanged(const QSize &size) = 0;
|
|
|
|
virtual SceneOpenGLTexturePrivate *createBackendTexture(SceneOpenGLTexture *texture) = 0;
|
|
|
|
|
2020-04-24 17:11:41 +00:00
|
|
|
/**
|
|
|
|
* Notifies about starting to paint.
|
|
|
|
*
|
|
|
|
* @p damage contains the reported damage as suggested by windows and effects on prepaint calls.
|
|
|
|
*/
|
2020-10-30 07:39:17 +00:00
|
|
|
virtual void aboutToStartPainting(int screenId, const QRegion &damage);
|
2017-09-08 20:30:18 +00:00
|
|
|
virtual bool makeCurrent() = 0;
|
|
|
|
virtual void doneCurrent() = 0;
|
2020-11-09 14:31:26 +00:00
|
|
|
virtual QRegion beginFrame(int screenId) = 0;
|
|
|
|
virtual void endFrame(int screenId, const QRegion &damage, const QRegion &damagedRegion) = 0;
|
2021-02-02 13:26:43 +00:00
|
|
|
/**
|
|
|
|
* Tries to directly scan out a surface to the screen)
|
|
|
|
* @return if the scanout fails (or is not supported on the specified screen)
|
|
|
|
*/
|
|
|
|
virtual bool scanout(int screenId, KWaylandServer::SurfaceInterface *surface);
|
2017-09-08 20:30:18 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief Returns the OverlayWindow used by the backend.
|
|
|
|
*
|
|
|
|
* A backend does not have to use an OverlayWindow, this is mostly for the X world.
|
|
|
|
* In case the backend does not use an OverlayWindow it is allowed to return @c null.
|
|
|
|
* It's the task of the caller to check whether it is @c null.
|
|
|
|
*
|
|
|
|
* @return :OverlayWindow*
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2019-08-07 17:33:20 +00:00
|
|
|
virtual OverlayWindow *overlayWindow() const;
|
2017-09-08 20:30:18 +00:00
|
|
|
/**
|
|
|
|
* @brief Whether the creation of the Backend failed.
|
|
|
|
*
|
|
|
|
* The SceneOpenGL should test whether the Backend got constructed correctly. If this method
|
|
|
|
* returns @c true, the SceneOpenGL should not try to start the rendering.
|
|
|
|
*
|
|
|
|
* @return bool @c true if the creation of the Backend failed, @c false otherwise.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2017-09-08 20:30:18 +00:00
|
|
|
bool isFailed() const {
|
|
|
|
return m_failed;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* @brief Whether the backend uses direct rendering.
|
|
|
|
*
|
|
|
|
* Some OpenGLScene modes require direct rendering. E.g. the OpenGL 2 should not be used
|
|
|
|
* if direct rendering is not supported by the Scene.
|
|
|
|
*
|
|
|
|
* @return bool @c true if the GL context is direct, @c false if indirect
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2017-09-08 20:30:18 +00:00
|
|
|
bool isDirectRendering() const {
|
|
|
|
return m_directRendering;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool supportsBufferAge() const {
|
|
|
|
return m_haveBufferAge;
|
|
|
|
}
|
|
|
|
|
2020-04-24 17:11:41 +00:00
|
|
|
bool supportsPartialUpdate() const
|
|
|
|
{
|
|
|
|
return m_havePartialUpdate;
|
|
|
|
}
|
|
|
|
bool supportsSwapBuffersWithDamage() const
|
|
|
|
{
|
|
|
|
return m_haveSwapBuffersWithDamage;
|
|
|
|
}
|
|
|
|
|
2020-10-12 06:45:05 +00:00
|
|
|
bool supportsSurfacelessContext() const
|
|
|
|
{
|
|
|
|
return m_haveSurfacelessContext;
|
2017-09-08 20:30:18 +00:00
|
|
|
}
|
2020-10-15 09:27:00 +00:00
|
|
|
bool supportsNativeFence() const
|
|
|
|
{
|
|
|
|
return m_haveNativeFence;
|
|
|
|
}
|
2021-02-02 13:26:43 +00:00
|
|
|
virtual bool directScanoutAllowed(int screen) const;
|
2017-09-08 20:30:18 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the damage that has accumulated since a buffer of the given age was presented.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2017-09-08 20:30:18 +00:00
|
|
|
QRegion accumulatedDamageHistory(int bufferAge) const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Saves the given region to damage history.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2017-09-08 20:30:18 +00:00
|
|
|
void addToDamageHistory(const QRegion ®ion);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The backend specific extensions (e.g. EGL/GLX extensions).
|
|
|
|
*
|
|
|
|
* Not the OpenGL (ES) extension!
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2017-09-08 20:30:18 +00:00
|
|
|
QList<QByteArray> extensions() const {
|
|
|
|
return m_extensions;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @returns whether the backend specific extensions contains @p extension.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2017-09-08 20:30:18 +00:00
|
|
|
bool hasExtension(const QByteArray &extension) const {
|
|
|
|
return m_extensions.contains(extension);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Copy a region of pixels from the current read to the current draw buffer
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2017-09-08 20:30:18 +00:00
|
|
|
void copyPixels(const QRegion ®ion);
|
|
|
|
|
2020-07-22 17:22:36 +00:00
|
|
|
virtual QSharedPointer<GLTexture> textureForOutput(AbstractOutput *output) const;
|
|
|
|
|
2017-09-08 20:30:18 +00:00
|
|
|
protected:
|
|
|
|
/**
|
|
|
|
* @brief Sets the backend initialization to failed.
|
|
|
|
*
|
|
|
|
* This method should be called by the concrete subclass in case the initialization failed.
|
|
|
|
* The given @p reason is logged as a warning.
|
|
|
|
*
|
|
|
|
* @param reason The reason why the initialization failed.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2017-09-08 20:30:18 +00:00
|
|
|
void setFailed(const QString &reason);
|
|
|
|
/**
|
|
|
|
* @brief Sets whether the OpenGL context is direct.
|
|
|
|
*
|
|
|
|
* Should be called by the concrete subclass once it is determined whether the OpenGL context is
|
|
|
|
* direct or indirect.
|
|
|
|
* If the subclass does not call this method, the backend defaults to @c false.
|
|
|
|
*
|
|
|
|
* @param direct @c true if the OpenGL context is direct, @c false if indirect
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2017-09-08 20:30:18 +00:00
|
|
|
void setIsDirectRendering(bool direct) {
|
|
|
|
m_directRendering = direct;
|
|
|
|
}
|
|
|
|
|
|
|
|
void setSupportsBufferAge(bool value) {
|
|
|
|
m_haveBufferAge = value;
|
|
|
|
}
|
|
|
|
|
2020-04-24 17:11:41 +00:00
|
|
|
void setSupportsPartialUpdate(bool value)
|
|
|
|
{
|
|
|
|
m_havePartialUpdate = value;
|
|
|
|
}
|
|
|
|
|
|
|
|
void setSupportsSwapBuffersWithDamage(bool value)
|
|
|
|
{
|
|
|
|
m_haveSwapBuffersWithDamage = value;
|
|
|
|
}
|
|
|
|
|
2020-10-12 06:45:05 +00:00
|
|
|
void setSupportsSurfacelessContext(bool value)
|
|
|
|
{
|
|
|
|
m_haveSurfacelessContext = value;
|
|
|
|
}
|
|
|
|
|
2020-10-15 09:27:00 +00:00
|
|
|
void setSupportsNativeFence(bool value)
|
|
|
|
{
|
|
|
|
m_haveNativeFence = value;
|
|
|
|
}
|
|
|
|
|
2017-09-08 20:30:18 +00:00
|
|
|
/**
|
|
|
|
* Sets the platform-specific @p extensions.
|
|
|
|
*
|
|
|
|
* These are the EGL/GLX extensions, not the OpenGL extensions
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2017-09-08 20:30:18 +00:00
|
|
|
void setExtensions(const QList<QByteArray> &extensions) {
|
|
|
|
m_extensions = extensions;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
/**
|
|
|
|
* @brief Whether direct rendering is used, defaults to @c false.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2017-09-08 20:30:18 +00:00
|
|
|
bool m_directRendering;
|
|
|
|
/**
|
|
|
|
* @brief Whether the backend supports GLX_EXT_buffer_age / EGL_EXT_buffer_age.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2017-09-08 20:30:18 +00:00
|
|
|
bool m_haveBufferAge;
|
2020-04-24 17:11:41 +00:00
|
|
|
/**
|
|
|
|
* @brief Whether the backend supports EGL_KHR_partial_update
|
|
|
|
*/
|
2020-11-24 16:10:04 +00:00
|
|
|
bool m_havePartialUpdate = false;
|
2020-04-24 17:11:41 +00:00
|
|
|
bool m_haveSwapBuffersWithDamage = false;
|
2020-10-12 06:45:05 +00:00
|
|
|
/**
|
|
|
|
* @brief Whether the backend supports EGL_KHR_surfaceless_context.
|
|
|
|
*/
|
|
|
|
bool m_haveSurfacelessContext = false;
|
2020-10-15 09:27:00 +00:00
|
|
|
/**
|
|
|
|
* @brief Whether the backend supports EGL_ANDROID_native_fence_sync.
|
|
|
|
*/
|
|
|
|
bool m_haveNativeFence = false;
|
2017-09-08 20:30:18 +00:00
|
|
|
/**
|
|
|
|
* @brief Whether the initialization failed, of course default to @c false.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2017-09-08 20:30:18 +00:00
|
|
|
bool m_failed;
|
|
|
|
/**
|
|
|
|
* @brief The damage history for the past 10 frames.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2017-09-08 20:30:18 +00:00
|
|
|
QList<QRegion> m_damageHistory;
|
|
|
|
QList<QByteArray> m_extensions;
|
|
|
|
};
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|