yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/glxbackend.h

129 lines
3.6 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_GLX_BACKEND_H
#define KWIN_GLX_BACKEND_H
#include "scene_opengl.h"
Add support for GLX_INTEL_swap_event Enable swap events and use them to defer rendering of the next frame until the last glXSwapBuffers() call has completed.
2014-08-07 12:16:35 +00:00
#include "x11eventfilter.h"
#include <memory>
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 KWin
{
class FBConfigInfo
{
public:
GLXFBConfig fbconfig;
int bind_texture_format;
int texture_targets;
int y_inverted;
int mipmap;
};
Add support for GLX_INTEL_swap_event Enable swap events and use them to defer rendering of the next frame until the last glXSwapBuffers() call has completed.
2014-08-07 12:16:35 +00:00
// ------------------------------------------------------------------
class SwapEventFilter : public X11EventFilter
{
public:
SwapEventFilter(xcb_drawable_t drawable);
bool event(xcb_generic_event_t *event) override;
private:
xcb_drawable_t m_drawable;
};
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
/**
* @brief OpenGL Backend using GLX over an X overlay window.
**/
class GlxBackend : public OpenGLBackend
{
public:
GlxBackend();
virtual ~GlxBackend();
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);
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 14:05:36 +00:00
virtual bool makeCurrent() override;
virtual void doneCurrent() override;
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;
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();
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:
void init();
bool initBuffer();
void waitSync();
bool initRenderingContext();
kwin: Simplify GLXBackend::initBufferConfigs() Use glXChooseFBConfig() instead of glXGetFBConfigs(), and prefer the first usable configuration instead of the last. Also rename initBufferConfigs() to initFbConfig().
2013-03-11 15:16:05 +00:00
bool initFbConfig();
Match the fbconfig visual depth to the window Not all RGBA 8888 fbconfigs in the NVIDIA driver have an associated X visual with a 32 bit depth. This fixes a regression from 88f807807380203a738785c8639ee80da6a6c9c4. Tested-by: Eike Hein <hein@kde.org>
2014-09-03 16:43:45 +00:00
void initVisualDepthHashTable();
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
void setSwapInterval(int interval);
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
Match the fbconfig visual depth to the window Not all RGBA 8888 fbconfigs in the NVIDIA driver have an associated X visual with a 32 bit depth. This fixes a regression from 88f807807380203a738785c8639ee80da6a6c9c4. Tested-by: Eike Hein <hein@kde.org>
2014-09-03 16:43:45 +00:00
int visualDepth(xcb_visualid_t visual) const;
glx: Use the X visual when choosing an FBConfig This adds a SceneOpenGL::Texture::load(..., xcb_visualid_t) overload, and uses it to bind window pixmaps to textures. By taking the RGBA masks in the visual into account when choosing an FBConfig for the GLXPixmap, we are able to disambiguate formats that have the same depth, such as GL_RGB10_A2 and GL_RGBA8.
2014-04-13 18:47:58 +00:00
FBConfigInfo *infoForVisual(xcb_visualid_t visual);
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;
kwin: Require Xcomposite 0.3 for OpenGL compositing Remove support for OpenGL compositing without using a composite overlay window. With this change kwin now also requires a double-buffered framebuffer configuration.
2013-03-11 15:27:24 +00:00
Window window;
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
GLXFBConfig fbconfig;
kwin: Require Xcomposite 0.3 for OpenGL compositing Remove support for OpenGL compositing without using a composite overlay window. With this change kwin now also requires a double-buffered framebuffer configuration.
2013-03-11 15:27:24 +00:00
GLXWindow glxWindow;
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
GLXContext ctx;
glx: Use the X visual when choosing an FBConfig This adds a SceneOpenGL::Texture::load(..., xcb_visualid_t) overload, and uses it to bind window pixmaps to textures. By taking the RGBA masks in the visual into account when choosing an FBConfig for the GLXPixmap, we are able to disambiguate formats that have the same depth, such as GL_RGB10_A2 and GL_RGBA8.
2014-04-13 18:47:58 +00:00
QHash<xcb_visualid_t, FBConfigInfo *> m_fbconfigHash;
Match the fbconfig visual depth to the window Not all RGBA 8888 fbconfigs in the NVIDIA driver have an associated X visual with a 32 bit depth. This fixes a regression from 88f807807380203a738785c8639ee80da6a6c9c4. Tested-by: Eike Hein <hein@kde.org>
2014-09-03 16:43:45 +00:00
QHash<xcb_visualid_t, int> m_visualDepthHash;
Add support for GLX_INTEL_swap_event Enable swap events and use them to defer rendering of the next frame until the last glXSwapBuffers() call has completed.
2014-08-07 12:16:35 +00:00
std::unique_ptr<SwapEventFilter> m_swapEventFilter;
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;
Use libepoxy to resolve GL functions Remove the manually written GL dispatch code, and use libepoxy to resolve functions. The only exceptions are GLX_MESA_swap_control, which is not in the XML API registry, and GL_ARB_robustness/GL_EXT_robustness. For the latter we want to resolve the functions to the same names on both GLES and desktop GL, and plug in our own implementations when the extension is not supported.
2014-02-11 18:57:06 +00:00
bool m_haveMESACopySubBuffer;
bool m_haveMESASwapControl;
bool m_haveEXTSwapControl;
bool m_haveSGISwapControl;
Add support for GLX_INTEL_swap_event Enable swap events and use them to defer rendering of the next frame until the last glXSwapBuffers() call has completed.
2014-08-07 12:16:35 +00:00
bool m_haveINTELSwapEvent;
hasWaitSync -> blocksForRetrace and syncsToVBlank since that's not the same. also autodetect triple buffering REVIEW: 109783
2013-03-28 20:52:26 +00:00
bool haveSwapInterval, haveWaitSync;
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 GlxTexture;
};
/**
* @brief Texture using an GLXPixmap.
**/
class GlxTexture : public SceneOpenGL::TexturePrivate
{
public:
virtual ~GlxTexture();
virtual void onDamage();
glx: Use the X visual when choosing an FBConfig This adds a SceneOpenGL::Texture::load(..., xcb_visualid_t) overload, and uses it to bind window pixmaps to textures. By taking the RGBA masks in the visual into account when choosing an FBConfig for the GLXPixmap, we are able to disambiguate formats that have the same depth, such as GL_RGB10_A2 and GL_RGBA8.
2014-04-13 18:47:58 +00:00
virtual bool loadTexture(xcb_pixmap_t pix, const QSize &size, xcb_visualid_t visual) 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
virtual OpenGLBackend *backend();
private:
friend class GlxBackend;
GlxTexture(SceneOpenGL::Texture *texture, GlxBackend *backend);
SceneOpenGL::Texture *q;
GlxBackend *m_backend;
GLXPixmap m_glxpixmap; // the glx pixmap the texture is bound to
};
} // namespace
#endif // KWIN_GLX_BACKEND_H
Reference in a new issue Copy permalink