vitalif
/
kwin
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
kwin/eglonxbackend.h

81 lines
2.4 KiB
C
Raw Normal View History

Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 19:14:23 +04:00
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2012 Martin Gräßlin <mgraesslin@kde.org>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#ifndef KWIN_EGL_ON_X_BACKEND_H
#define KWIN_EGL_ON_X_BACKEND_H
#include "scene_opengl.h"
namespace KWin
{
/**
* @brief OpenGL Backend using Egl windowing system over an X overlay window.
**/
class EglOnXBackend : public OpenGLBackend
{
public:
EglOnXBackend();
virtual ~EglOnXBackend();
virtual void screenGeometryChanged(const QSize &size);
virtual SceneOpenGL::TexturePrivate *createBackendTexture(SceneOpenGL::Texture *texture);
kwin: Prepare the backend interface for EXT_buffer_age Allow prepareRenderingFrame() to return a region that will be repainted in addition to the damaged region. Pass both the damaged region and the repainted region, which may be larger, as parameters to endRenderingFrame().
2013-11-21 13:39:29 +04:00
virtual QRegion prepareRenderingFrame();
Merge branch 'KDE/4.11' into master Conflicts: CMakeLists.txt doc/kcontrol/screensaver/index.docbook kcontrol/krdb/krdb.cpp kscreensaver/kblank_screensaver/kblank.desktop kscreensaver/krandom_screensaver/krandom.desktop kscreensaver/libkscreensaver/main.cpp ksplash/ksplashqml/SplashApp.cpp kstyles/oxygen/config/main.cpp kstyles/oxygen/demo/main.cpp kstyles/oxygen/oxygenstylehelper.cpp kwin/clients/oxygen/config/oxygenexceptiondialog.cpp kwin/clients/oxygen/config/ui/oxygenconfigurationui.ui kwin/clients/oxygen/config/ui/oxygenexceptiondialog.ui kwin/clients/oxygen/demo/main.cpp kwin/clients/oxygen/oxygenconfigdata.kcfg kwin/egl_wayland_backend.cpp kwin/eglonxbackend.h kwin/glxbackend.cpp kwin/glxbackend.h kwin/kcmkwin/kwinoptions/kwinactions.desktop kwin/scene_opengl.cpp kwin/scene_opengl.h plasma/desktop/applets/pager/pager.cpp plasma/desktop/shell/activitymanager/activitymanager.cpp plasma/desktop/shell/activitymanager/activitymanager.h plasma/desktop/shell/controllerwindow.cpp plasma/desktop/shell/data/plasma-desktop.desktop plasma/generic/dataengines/geolocation/geolocation.cpp plasma/generic/dataengines/nowplaying/plasma-dataengine-nowplaying.desktop plasma/generic/wallpapers/color/plasma-wallpaper-color.desktop plasma/generic/wallpapers/image/image.cpp plasma/generic/wallpapers/image/image.h
2014-01-07 12:28:59 +04:00
virtual void endRenderingFrame(const QRegion &damage, const QRegion &damagedRegion);
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 18:05:36 +04:00
virtual bool makeCurrent() override;
virtual void doneCurrent() override;
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 19:14:23 +04:00
protected:
kwin: Rename flushBuffer() to present() This function doesn't flush any buffered commands, it presents or posts the color buffer to the surface to which the GL context is bound.
2012-10-07 15:43:31 +04:00
virtual void present();
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 19:14:23 +04:00
private:
void init();
bool initBufferConfigs();
bool initRenderingContext();
EGLDisplay dpy;
EGLConfig config;
EGLSurface surface;
EGLContext ctx;
int surfaceHasSubPost;
kwin: Add support for EXT_buffer_age This patch adds support for GLX_EXT_buffer_age, and EGL_EXT_buffer_age on X11.
2013-11-21 13:44:06 +04:00
int m_bufferAge;
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 19:14:23 +04:00
friend class EglTexture;
};
/**
* @brief Texture using an EGLImageKHR.
**/
class EglTexture : public SceneOpenGL::TexturePrivate
{
public:
virtual ~EglTexture();
virtual void onDamage();
virtual void findTarget();
virtual bool loadTexture(const Pixmap& pix, const QSize& size, int depth);
virtual OpenGLBackend *backend();
private:
friend class EglOnXBackend;
EglTexture(SceneOpenGL::Texture *texture, EglOnXBackend *backend);
SceneOpenGL::Texture *q;
EglOnXBackend *m_backend;
EGLImageKHR m_image;
};
} // namespace
#endif // KWIN_EGL_ON_X_BACKEND_H