yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/plugins/platforms/x11/common/eglonxbackend.h

106 lines
3.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 15:14:23 +00: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
Introduce a shared base class for the EGL backends There's quite some overlap and duplicated code. This AbstractEglBackend tries to merge the two backends a little bit again. This also introduces an AbstractEglTexture which supports both X11 and Wayland "pixmaps" so that EglOnXBackend can support Wayland buffers.
2015-03-19 13:46:39 +00:00
#include "abstract_egl_backend.h"
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 15:14:23 +00:00
#include "scene_opengl.h"
namespace KWin
{
/**
* @brief OpenGL Backend using Egl windowing system over an X overlay window.
**/
Create a plugin for each of the wayland backends Each of the backends becomes a plugin. This allows kwin_wayland to load the requested plugin and kwin itself doesn't need to link all the libraries needed. E.g. libdrm is no longer linked if running kwin_x11. Also this allows to create backends for the non-standard EGL platforms (examples could be raspberrypi or Android devices).
2015-05-05 15:58:09 +00:00
class KWIN_EXPORT EglOnXBackend : public AbstractEglBackend
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 15:14:23 +00:00
{
public:
Remove KWin::display from kwinglobals Summary: And finally nothing inside libkwineffects, libkwinglutils, libkwinxrenderutils and kwineffect and kwin core uses KWin::display. We are finally XLib free! This change drops KWin::display and removes the include to QX11Info from kwinglobals.h. And the libraries no longer need to link X11Extras. Due to that removal a few seeming unrelated changes are required to add the include where needed and linkage to X11Extras. The biggest change is to x11 platform plugin which still needs the display and caches it in the Platform and passes it to various places in a way that the code doesn't need to be adjusted. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3337
2016-11-11 08:59:46 +00:00
EglOnXBackend(Display *display);
[wayland] Don't call into X11WindowedBackend from EglOnXBackend Instead of having a ctor which takes the backend, it's a ctor which takes all the information needed from the backend.
2015-05-05 13:35:12 +00:00
explicit EglOnXBackend(xcb_connection_t *connection, Display *display, xcb_window_t rootWindow, int screenNumber, xcb_window_t renderingWindow);
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 15:14:23 +00:00
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 09:39:29 +00: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 08:28:59 +00:00
virtual void endRenderingFrame(const QRegion &damage, const QRegion &damagedRegion);
A Scene doesn't need to use an X11 Overlay Window Only the X based Scenes need an overlay window, so the Compositor doesn't need to check for it in the Wayland case. OverlayWindow is moved from OpenGLBackend to the sub classes which need to provide it.
2013-06-19 10:26:34 +00:00
virtual OverlayWindow* overlayWindow() override;
virtual bool usesOverlayWindow() const override;
Add pure virtual OpenGLBackend::init() method All backends already have an init method so far called from the ctor. This change moves the call to init out of the OpenGL backends and makes it the responsibility of the creating code to also call init on the backend. This change makes it easier to have virtual methods being called during the initialization.
2015-11-25 12:09:28 +00:00
void init() 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 15:14:23 +00:00
Move the loadTexture for X11 pixmap functionality to the EglOnXBackend Summary: To use eglCreateImageKhr for an X11 pixmap we need an EGLDisplay created for the same XDisplay as the X11 pixmap. This means if we created an EGLDisplay for a GBM device, we are not allowed to load a texture from the X11 pixmap and can result in a crash in the driver. Similar in the nested X11 setup the EGLDisplay is created for the rendering window, but the X11 pixmaps are from the Xwayland server KWin started. They don't belong to the same windowing system. This change addresses this problem by moving the loading of X11 pixmaps from AbstractEglTexture to EglTexture of the EglOnX11Backend. Thus for any usage on a non X11 platform we cannot hit the code path any more. In addition the nested X11 platform can indicate that it doesn't support it and thus also doesn't go through the code path. Test Plan: Tested standalone and nested X11 platform Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D1857
2016-06-14 07:01:42 +00:00
bool isX11TextureFromPixmapSupported() const {
return m_x11TextureFromPixmapSupported;
}
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 15:14:23 +00: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 11:43:31 +00:00
virtual void present();
Refactoring of EglOnXBackend to allow implementing subclasses The aim is to allow having an implementing subclass which uses multiple windows to render to.
2015-11-25 12:32:36 +00:00
void presentSurface(EGLSurface surface, const QRegion &damage, const QRect &screenGeometry);
virtual bool createSurfaces();
EGLSurface createSurface(xcb_window_t window);
void setHavePlatformBase(bool have) {
m_havePlatformBase = have;
}
bool havePlatformBase() const {
return m_havePlatformBase;
}
bool makeContextCurrent(const EGLSurface &surface);
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 15:14:23 +00:00
Move the loadTexture for X11 pixmap functionality to the EglOnXBackend Summary: To use eglCreateImageKhr for an X11 pixmap we need an EGLDisplay created for the same XDisplay as the X11 pixmap. This means if we created an EGLDisplay for a GBM device, we are not allowed to load a texture from the X11 pixmap and can result in a crash in the driver. Similar in the nested X11 setup the EGLDisplay is created for the rendering window, but the X11 pixmaps are from the Xwayland server KWin started. They don't belong to the same windowing system. This change addresses this problem by moving the loading of X11 pixmaps from AbstractEglTexture to EglTexture of the EglOnX11Backend. Thus for any usage on a non X11 platform we cannot hit the code path any more. In addition the nested X11 platform can indicate that it doesn't support it and thus also doesn't go through the code path. Test Plan: Tested standalone and nested X11 platform Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D1857
2016-06-14 07:01:42 +00:00
void setX11TextureFromPixmapSupported(bool set) {
m_x11TextureFromPixmapSupported = set;
}
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 15:14:23 +00:00
private:
bool initBufferConfigs();
bool initRenderingContext();
A Scene doesn't need to use an X11 Overlay Window Only the X based Scenes need an overlay window, so the Compositor doesn't need to check for it in the Wayland case. OverlayWindow is moved from OpenGLBackend to the sub classes which need to provide it.
2013-06-19 10:26:34 +00:00
/**
* @brief The OverlayWindow used by this Backend.
**/
OverlayWindow *m_overlayWindow;
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 15:14:23 +00:00
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 09:44:06 +00:00
int m_bufferAge;
Allow using EGLOnXBackend with X11WindowedBackend Mostly refactoring to not take the global X11 information (connection, display, etc.). Adds a dedicated ctor overload which takes the X11WindowedBackend. SceneOpenGL is adjusted to create an EGLOnXBackend instead of Wayland one if the X11WindowedBackend is used.
2015-03-19 10:26:53 +00:00
bool m_usesOverlayWindow;
xcb_connection_t *m_connection;
Display *m_x11Display;
xcb_window_t m_rootWindow;
int m_x11ScreenNumber;
[wayland] Don't call into X11WindowedBackend from EglOnXBackend Instead of having a ctor which takes the backend, it's a ctor which takes all the information needed from the backend.
2015-05-05 13:35:12 +00:00
xcb_window_t m_renderingWindow = XCB_WINDOW_NONE;
Refactoring of EglOnXBackend to allow implementing subclasses The aim is to allow having an implementing subclass which uses multiple windows to render to.
2015-11-25 12:32:36 +00:00
bool m_havePlatformBase = false;
Move the loadTexture for X11 pixmap functionality to the EglOnXBackend Summary: To use eglCreateImageKhr for an X11 pixmap we need an EGLDisplay created for the same XDisplay as the X11 pixmap. This means if we created an EGLDisplay for a GBM device, we are not allowed to load a texture from the X11 pixmap and can result in a crash in the driver. Similar in the nested X11 setup the EGLDisplay is created for the rendering window, but the X11 pixmaps are from the Xwayland server KWin started. They don't belong to the same windowing system. This change addresses this problem by moving the loading of X11 pixmaps from AbstractEglTexture to EglTexture of the EglOnX11Backend. Thus for any usage on a non X11 platform we cannot hit the code path any more. In addition the nested X11 platform can indicate that it doesn't support it and thus also doesn't go through the code path. Test Plan: Tested standalone and nested X11 platform Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D1857
2016-06-14 07:01:42 +00:00
bool m_x11TextureFromPixmapSupported = true;
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 15:14:23 +00:00
friend class EglTexture;
};
/**
* @brief Texture using an EGLImageKHR.
**/
Introduce a shared base class for the EGL backends There's quite some overlap and duplicated code. This AbstractEglBackend tries to merge the two backends a little bit again. This also introduces an AbstractEglTexture which supports both X11 and Wayland "pixmaps" so that EglOnXBackend can support Wayland buffers.
2015-03-19 13:46:39 +00:00
class EglTexture : public AbstractEglTexture
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 15:14:23 +00:00
{
public:
virtual ~EglTexture();
virtual void onDamage();
Move the loadTexture for X11 pixmap functionality to the EglOnXBackend Summary: To use eglCreateImageKhr for an X11 pixmap we need an EGLDisplay created for the same XDisplay as the X11 pixmap. This means if we created an EGLDisplay for a GBM device, we are not allowed to load a texture from the X11 pixmap and can result in a crash in the driver. Similar in the nested X11 setup the EGLDisplay is created for the rendering window, but the X11 pixmaps are from the Xwayland server KWin started. They don't belong to the same windowing system. This change addresses this problem by moving the loading of X11 pixmaps from AbstractEglTexture to EglTexture of the EglOnX11Backend. Thus for any usage on a non X11 platform we cannot hit the code path any more. In addition the nested X11 platform can indicate that it doesn't support it and thus also doesn't go through the code path. Test Plan: Tested standalone and nested X11 platform Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D1857
2016-06-14 07:01:42 +00:00
bool loadTexture(WindowPixmap *pixmap) 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 15:14:23 +00:00
private:
Move the loadTexture for X11 pixmap functionality to the EglOnXBackend Summary: To use eglCreateImageKhr for an X11 pixmap we need an EGLDisplay created for the same XDisplay as the X11 pixmap. This means if we created an EGLDisplay for a GBM device, we are not allowed to load a texture from the X11 pixmap and can result in a crash in the driver. Similar in the nested X11 setup the EGLDisplay is created for the rendering window, but the X11 pixmaps are from the Xwayland server KWin started. They don't belong to the same windowing system. This change addresses this problem by moving the loading of X11 pixmaps from AbstractEglTexture to EglTexture of the EglOnX11Backend. Thus for any usage on a non X11 platform we cannot hit the code path any more. In addition the nested X11 platform can indicate that it doesn't support it and thus also doesn't go through the code path. Test Plan: Tested standalone and nested X11 platform Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D1857
2016-06-14 07:01:42 +00:00
bool loadTexture(xcb_pixmap_t pix, const QSize &size);
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 15:14:23 +00:00
friend class EglOnXBackend;
EglTexture(SceneOpenGL::Texture *texture, EglOnXBackend *backend);
Move the loadTexture for X11 pixmap functionality to the EglOnXBackend Summary: To use eglCreateImageKhr for an X11 pixmap we need an EGLDisplay created for the same XDisplay as the X11 pixmap. This means if we created an EGLDisplay for a GBM device, we are not allowed to load a texture from the X11 pixmap and can result in a crash in the driver. Similar in the nested X11 setup the EGLDisplay is created for the rendering window, but the X11 pixmaps are from the Xwayland server KWin started. They don't belong to the same windowing system. This change addresses this problem by moving the loading of X11 pixmaps from AbstractEglTexture to EglTexture of the EglOnX11Backend. Thus for any usage on a non X11 platform we cannot hit the code path any more. In addition the nested X11 platform can indicate that it doesn't support it and thus also doesn't go through the code path. Test Plan: Tested standalone and nested X11 platform Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D1857
2016-06-14 07:01:42 +00:00
EglOnXBackend *m_backend;
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 15:14:23 +00:00
};
} // namespace
#endif // KWIN_EGL_ON_X_BACKEND_H
Reference in a new issue Copy permalink