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

720 lines
23 KiB
C++
Raw Normal View History

Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
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
Copyright (C) 2012 Martin Gräßlin <mgraesslin@kde.org>
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
Based on glcompmgr code by Felix Bellaby.
Using code from Compiz and Beryl.
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/>.
*********************************************************************/
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
// TODO: cmake magic
#ifndef KWIN_HAVE_OPENGLES
// own
#include "glxbackend.h"
// kwin
#include "options.h"
#include "utils.h"
#include "overlaywindow.h"
// kwin libs
#include <kwinglplatform.h>
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
#include <kwinxrenderutils.h>
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
// Qt
#include <QDebug>
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
#include <QOpenGLContext>
fix scheduling the repaints repaints caused by effects so far polluted the timing calculations since they started the timer on the old vsync offset This (together with undercut timing) lead to multiple frames in the buffer queue, and ultimately to a blocking swap For unsynced painting, it simply caused wrong timings - leading to "well, kinda around 60Hz - could be 75 as just well". REVIEW: 112368 CCBUG: 322060 that part is fixed in 4.11.2
2013-08-29 23:30:13 +00:00
// system
#include <unistd.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
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
#include <tuple>
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
{
GlxBackend::GlxBackend()
: OpenGLBackend()
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
, m_overlayWindow(new 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(None)
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
, fbconfig(NULL)
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(None)
Enable C++11 globally
2013-07-22 13:39:54 +00:00
, ctx(nullptr)
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
, m_bufferAge(0)
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
, haveSwapInterval(false)
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
{
init();
}
GlxBackend::~GlxBackend()
{
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
if (isFailed()) {
m_overlayWindow->destroy();
}
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
// TODO: cleanup in error case
// do cleanup after initBuffer()
cleanupGL();
Don't call into GL without a context After losing current from the EGL or GLX context, calls to the GL or GLES functions have undefined behavior. Perform all cleanup that may touch OpenGL and check for GL errors before losing current from the context. REVIEW: 115311
2014-01-24 14:38:45 +00:00
checkGLError("Cleanup");
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
doneCurrent();
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
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
if (ctx)
glXDestroyContext(display(), ctx);
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
if (glxWindow)
glXDestroyWindow(display(), glxWindow);
if (window)
XDestroyWindow(display(), window);
overlayWindow()->destroy();
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
delete 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
}
hasWaitSync -> blocksForRetrace and syncsToVBlank since that's not the same. also autodetect triple buffering REVIEW: 109783
2013-03-28 20:52:26 +00:00
static bool gs_tripleBufferUndetected = true;
static bool gs_tripleBufferNeedsDetection = false;
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
void GlxBackend::init()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
initGLX();
Do not resolve glx functions specified in GLX 1.3 According to the OpenGL ABI for Linux GLX 1.3 is a minimum requirement. Therefore we do not need to resolve the symbols which are present in that version. KWin did always require at least 1.3, for all the resolved functions there were checks in the Scene, but they might have been incorrect. Instead now the GLX version is checked and OpenGL compositing is blocked if there is not at least GLX 1.3. REVIEW: 106704
2012-10-03 08:28:43 +00:00
// require at least GLX 1.3
if (!hasGLXVersion(1, 3)) {
Fix no cast to/from ASCII intrduced issues * "" needs to be wrapped in QStringLiteral * QString::fromUtf8 needed for const char* and QByteArray * QByteArray::constData() needed to get to the const char*
2013-07-23 05:02:52 +00:00
setFailed(QStringLiteral("Requires at least GLX 1.3"));
Do not resolve glx functions specified in GLX 1.3 According to the OpenGL ABI for Linux GLX 1.3 is a minimum requirement. Therefore we do not need to resolve the symbols which are present in that version. KWin did always require at least 1.3, for all the resolved functions there were checks in the Scene, but they might have been incorrect. Instead now the GLX version is checked and OpenGL compositing is blocked if there is not at least GLX 1.3. REVIEW: 106704
2012-10-03 08:28:43 +00:00
return;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
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
if (!initBuffer()) {
Fix no cast to/from ASCII intrduced issues * "" needs to be wrapped in QStringLiteral * QString::fromUtf8 needed for const char* and QByteArray * QByteArray::constData() needed to get to the const char*
2013-07-23 05:02:52 +00:00
setFailed(QStringLiteral("Could not initialize the buffer"));
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
return;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
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
if (!initRenderingContext()) {
Fix no cast to/from ASCII intrduced issues * "" needs to be wrapped in QStringLiteral * QString::fromUtf8 needed for const char* and QByteArray * QByteArray::constData() needed to get to the const char*
2013-07-23 05:02:52 +00:00
setFailed(QStringLiteral("Could not initialize rendering context"));
KWin requires Mesa 7.10 for OpenGL/GLX If OpenGL compositing is tried in GLX with a Mesa driver not at least 7.10 we stop OpenGL compositing. For OpenGL ES we just assume that all Mesa drivers are fine, so no requirement.
2011-04-28 20:06:21 +00:00
return;
}
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
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
// Initialize OpenGL
GLPlatform *glPlatform = GLPlatform::instance();
Provide OpenGL over Egl The Egl backend is decoupled from the OpenGL ES build option which makes it possible to use it as a replacement for glx. To make this possible a new build flag is added when egl is available at compile time and any egl specific code is now ifdefed with this flag instead of the gles flag. In addition at runtime a windowing system enum value is passed to the various detect methods to have egl/glx specific detection for e.g. function pointer resolving. By default egl is used if compiled with OpenGL ES, otherwise glx is used. But in the non-gles case the windowing system can be selected through the new environment variable KWIN_OPENGL_INTERFACE. Setting this variable to "egl" the EglOnXBackend is used. REVIEW: 106632
2012-09-29 11:19:35 +00:00
glPlatform->detect(GlxPlatformInterface);
ignore unredirection configuration on intel the only thing it does on these systems is cause users trouble because usually when there's a client where unredirection makes sense, that uses OpenGL - and then things break in the driver. CCBUG: 252817 REVIEW: 111476
2013-07-10 18:48:11 +00:00
if (GLPlatform::instance()->driver() == Driver_Intel)
options->setUnredirectFullscreen(false); // bug #252817
keep buffer swap pref automatic until GPU detected enforce to "e" (cheap) when driver is still unknown after detection must be assumed to have run, so a sane value is available when the context is up BUG: 322355 FIXED-IN: 4.11 REVIEW: 111548
2013-07-17 13:44:42 +00:00
options->setGlPreferBufferSwap(options->glPreferBufferSwap()); // resolve autosetting
if (options->glPreferBufferSwap() == Options::AutoSwapStrategy)
options->setGlPreferBufferSwap('e'); // for unknown drivers - should not happen
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
glPlatform->printResults();
Provide OpenGL over Egl The Egl backend is decoupled from the OpenGL ES build option which makes it possible to use it as a replacement for glx. To make this possible a new build flag is added when egl is available at compile time and any egl specific code is now ifdefed with this flag instead of the gles flag. In addition at runtime a windowing system enum value is passed to the various detect methods to have egl/glx specific detection for e.g. function pointer resolving. By default egl is used if compiled with OpenGL ES, otherwise glx is used. But in the non-gles case the windowing system can be selected through the new environment variable KWIN_OPENGL_INTERFACE. Setting this variable to "egl" the EglOnXBackend is used. REVIEW: 106632
2012-09-29 11:19:35 +00:00
initGL(GlxPlatformInterface);
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
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
// Check whether certain features are supported
Make the GL extension list a QList<QByteArray> It doesn't make sense to convert the extension names to QStrings. This also replaces the QString parameter in hasGLExtension() with a QByteArray and adjusts all callers.
2014-02-11 18:35:54 +00:00
m_haveMESACopySubBuffer = hasGLExtension(QByteArrayLiteral("GLX_MESA_copy_sub_buffer"));
m_haveMESASwapControl = hasGLExtension(QByteArrayLiteral("GLX_MESA_swap_control"));
m_haveEXTSwapControl = hasGLExtension(QByteArrayLiteral("GLX_EXT_swap_control"));
m_haveSGISwapControl = hasGLExtension(QByteArrayLiteral("GLX_SGI_swap_control"));
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
haveSwapInterval = m_haveMESASwapControl || m_haveEXTSwapControl || m_haveSGISwapControl;
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
setSupportsBufferAge(false);
Make the GL extension list a QList<QByteArray> It doesn't make sense to convert the extension names to QStrings. This also replaces the QString parameter in hasGLExtension() with a QByteArray and adjusts all callers.
2014-02-11 18:35:54 +00:00
if (hasGLExtension(QByteArrayLiteral("GLX_EXT_buffer_age"))) {
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
const QByteArray useBufferAge = qgetenv("KWIN_USE_BUFFER_AGE");
if (useBufferAge != "0")
setSupportsBufferAge(true);
}
hasWaitSync -> blocksForRetrace and syncsToVBlank since that's not the same. also autodetect triple buffering REVIEW: 109783
2013-03-28 20:52:26 +00:00
setSyncsToVBlank(false);
setBlocksForRetrace(false);
haveWaitSync = false;
gs_tripleBufferNeedsDetection = false;
m_swapProfiler.init();
remove GlVSync option (it has no UI anymore) Based on (revision 2 of) https://git.reviewboard.kde.org/r/109086/ by Thomas Lübking REVIEW: 109086
2013-03-27 10:34:25 +00:00
const bool wantSync = options->glPreferBufferSwap() != Options::NoSwapEncourage;
hasWaitSync -> blocksForRetrace and syncsToVBlank since that's not the same. also autodetect triple buffering REVIEW: 109783
2013-03-28 20:52:26 +00:00
if (wantSync && glXIsDirect(display(), ctx)) {
if (haveSwapInterval) { // glXSwapInterval is preferred being more reliable
setSwapInterval(1);
setSyncsToVBlank(true);
const QByteArray tripleBuffer = qgetenv("KWIN_TRIPLE_BUFFER");
if (!tripleBuffer.isEmpty()) {
setBlocksForRetrace(qstrcmp(tripleBuffer, "0") == 0);
gs_tripleBufferUndetected = false;
}
gs_tripleBufferNeedsDetection = gs_tripleBufferUndetected;
Make the GL extension list a QList<QByteArray> It doesn't make sense to convert the extension names to QStrings. This also replaces the QString parameter in hasGLExtension() with a QByteArray and adjusts all callers.
2014-02-11 18:35:54 +00:00
} else if (hasGLExtension(QByteArrayLiteral("GLX_SGI_video_sync"))) {
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
unsigned int sync;
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
if (glXGetVideoSyncSGI(&sync) == 0 && glXWaitVideoSyncSGI(1, 0, &sync) == 0) {
hasWaitSync -> blocksForRetrace and syncsToVBlank since that's not the same. also autodetect triple buffering REVIEW: 109783
2013-03-28 20:52:26 +00:00
setSyncsToVBlank(true);
setBlocksForRetrace(true);
haveWaitSync = true;
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
} else
hasWaitSync -> blocksForRetrace and syncsToVBlank since that's not the same. also autodetect triple buffering REVIEW: 109783
2013-03-28 20:52:26 +00:00
qWarning() << "NO VSYNC! glXSwapInterval is not supported, glXWaitVideoSync is supported but broken";
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
} else
hasWaitSync -> blocksForRetrace and syncsToVBlank since that's not the same. also autodetect triple buffering REVIEW: 109783
2013-03-28 20:52:26 +00:00
qWarning() << "NO VSYNC! neither glSwapInterval nor glXWaitVideoSync are supported";
remove GlVSync option (it has no UI anymore) Based on (revision 2 of) https://git.reviewboard.kde.org/r/109086/ by Thomas Lübking REVIEW: 109086
2013-03-27 10:34:25 +00:00
} else {
// disable v-sync (if possible)
setSwapInterval(0);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Add support for OpenGL in VirtualBox OpenGL is properly working if there is a direct rendering context. If LIBGL_ALWAYS_INDIRECT is set VirtualBox falls back to Mesa's software rasterizer. So in order to get OpenGL the driver is now whitelisted in the opengltest. GLPlatform is extended to recognize the VirtualBox driver and has new methods to report whether it is a virtual machine and VirtualBox. The detection is rather limited as we don't get access to the underlying hardware, so we do not know whether the features are really supported. We need to trust the driver here in announcing the right extensions. The driver does not provide glxQueryDrawable although it is part of GLX 1.3. A hack is added in the glxbackend to set the function pointer to NULL. This can unfortunately not be done in glxResolveFunctions() as QueryDrawable seems not to be provided by an extension (at least not listed in the OpenGL registry) and getProcAddress resolves a function but it only prints an OpenGL Warning to stderr. As a note: the driver reports that it is using XSHM for GLX_EXT_texture_from_pixmap. REVIEW: 106821
2012-10-13 08:33:38 +00:00
if (glPlatform->isVirtualBox()) {
// VirtualBox does not support glxQueryDrawable
// this should actually be in kwinglutils_funcs, but QueryDrawable seems not to be provided by an extension
// and the GLPlatform has not been initialized at the moment when initGLX() is called.
glXQueryDrawable = NULL;
}
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
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
setIsDirectRendering(bool(glXIsDirect(display(), ctx)));
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
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "Direct rendering:" << isDirectRendering() << endl;
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
initVisualDepthHashTable();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
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
bool GlxBackend::initRenderingContext()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
[kwin] Drop testapp for detecting whether direct rendering works on glx The main purpose of the opengl testapp was to set the environment variable LIBGL_ALWAYS_INDIRECT if direct rendering is not supported before glx gets initialized. With Qt5 we may no longer set this environment variable. QtQuick requires direct rendering. On IvyBridge QtQuick is crashing if the variable is set. Thus we are no longer allowed to set it and thus the complete test becomes pointless. The test app basically whitelisted most drivers anyway, the only drivers which were problematic are the proprietary Catalyst drivers. It that's still a problem we can also disable OpenGL compositing on those drivers through the recommendation in the GLPlatform. This also means that the KWIN_DIRECT_GL variable is no longer useful.
2013-11-05 13:48:40 +00:00
const bool direct = true;
kwin: Simplify GLXBackend::initRenderingContext() glXCreateNewContext() is supposed to return NULL on failure, so let's assume that it does. Don't try to create an indirect context when creating a direct context failed. glXCreateNewContext() should return an indirect context when a direct context cannot be created.
2013-03-11 15:19:45 +00:00
kwin: Use glXCreateContextAttribsARB() when it's supported
2013-03-13 15:09:05 +00:00
// Use glXCreateContextAttribsARB() when it's available
Make the GL extension list a QList<QByteArray> It doesn't make sense to convert the extension names to QStrings. This also replaces the QString parameter in hasGLExtension() with a QByteArray and adjusts all callers.
2014-02-11 18:35:54 +00:00
if (hasGLExtension(QByteArrayLiteral("GLX_ARB_create_context"))) {
kwin/glx: Add support for GLX_ARB_create_context_robustness Request a context with robust buffer access behavior, and set the reset notification strategy to GLX_LOSE_CONTEXT_ON_RESET_ARB.
2013-05-19 14:28:48 +00:00
const int attribs_31_core_robustness[] = {
GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
GLX_CONTEXT_MINOR_VERSION_ARB, 1,
kwin: Don't set the forward-compatible bit This flag seems to be ignored by several OpenGL implementations, so don't set it for now. Mesa may also stop accepting this flag until forward-compatible contexts are fully supported.
2013-08-07 21:01:14 +00:00
GLX_CONTEXT_FLAGS_ARB, GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB,
kwin/glx: Add support for GLX_ARB_create_context_robustness Request a context with robust buffer access behavior, and set the reset notification strategy to GLX_LOSE_CONTEXT_ON_RESET_ARB.
2013-05-19 14:28:48 +00:00
GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, GLX_LOSE_CONTEXT_ON_RESET_ARB,
0
};
kwin/glx: Try to create an OpenGL 3.1 core context
2013-03-13 15:24:55 +00:00
const int attribs_31_core[] = {
GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
GLX_CONTEXT_MINOR_VERSION_ARB, 1,
0
};
kwin/glx: Add support for GLX_ARB_create_context_robustness Request a context with robust buffer access behavior, and set the reset notification strategy to GLX_LOSE_CONTEXT_ON_RESET_ARB.
2013-05-19 14:28:48 +00:00
const int attribs_legacy_robustness[] = {
GLX_CONTEXT_FLAGS_ARB, GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB,
GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, GLX_LOSE_CONTEXT_ON_RESET_ARB,
0
};
kwin/glx: Try to create an OpenGL 3.1 core context
2013-03-13 15:24:55 +00:00
const int attribs_legacy[] = {
non-empty attrib_list for glXCreateContextAttribsARB empty list is legal but causes bogus context on at least i915 BUG: 321843 REVIEW: 111355 FIXED-IN: 4.11
2013-07-01 18:38:40 +00:00
GLX_CONTEXT_MAJOR_VERSION_ARB, 1,
GLX_CONTEXT_MINOR_VERSION_ARB, 2,
kwin/glx: Try to create an OpenGL 3.1 core context
2013-03-13 15:24:55 +00:00
0
};
Make the GL extension list a QList<QByteArray> It doesn't make sense to convert the extension names to QStrings. This also replaces the QString parameter in hasGLExtension() with a QByteArray and adjusts all callers.
2014-02-11 18:35:54 +00:00
const bool have_robustness = hasGLExtension(QByteArrayLiteral("GLX_ARB_create_context_robustness"));
kwin/glx: Add support for GLX_ARB_create_context_robustness Request a context with robust buffer access behavior, and set the reset notification strategy to GLX_LOSE_CONTEXT_ON_RESET_ARB.
2013-05-19 14:28:48 +00:00
kwin/glx: Try to create an OpenGL 3.1 core context
2013-03-13 15:24:55 +00:00
// Try to create a 3.1 context first
kwin/glx: Add support for GLX_ARB_create_context_robustness Request a context with robust buffer access behavior, and set the reset notification strategy to GLX_LOSE_CONTEXT_ON_RESET_ARB.
2013-05-19 14:28:48 +00:00
if (options->glCoreProfile()) {
if (have_robustness)
ctx = glXCreateContextAttribsARB(display(), fbconfig, 0, direct, attribs_31_core_robustness);
if (!ctx)
ctx = glXCreateContextAttribsARB(display(), fbconfig, 0, direct, attribs_31_core);
}
if (!ctx && have_robustness)
ctx = glXCreateContextAttribsARB(display(), fbconfig, 0, direct, attribs_legacy_robustness);
kwin/glx: Try to create an OpenGL 3.1 core context
2013-03-13 15:24:55 +00:00
if (!ctx)
ctx = glXCreateContextAttribsARB(display(), fbconfig, 0, direct, attribs_legacy);
kwin: Use glXCreateContextAttribsARB() when it's supported
2013-03-13 15:09:05 +00:00
}
if (!ctx)
ctx = glXCreateNewContext(display(), fbconfig, GLX_RGBA_TYPE, NULL, direct);
kwin: Simplify GLXBackend::initRenderingContext() glXCreateNewContext() is supposed to return NULL on failure, so let's assume that it does. Don't try to create an indirect context when creating a direct context failed. glXCreateNewContext() should return an indirect context when a direct context cannot be created.
2013-03-11 15:19:45 +00:00
if (!ctx) {
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "Failed to create an OpenGL context.";
kwin: Simplify GLXBackend::initRenderingContext() glXCreateNewContext() is supposed to return NULL on failure, so let's assume that it does. Don't try to create an indirect context when creating a direct context failed. glXCreateNewContext() should return an indirect context when a direct context cannot be created.
2013-03-11 15:19:45 +00:00
return false;
}
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
if (!glXMakeCurrent(display(), glxWindow, ctx)) {
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "Failed to make the OpenGL context current.";
kwin: Simplify GLXBackend::initRenderingContext() glXCreateNewContext() is supposed to return NULL on failure, so let's assume that it does. Don't try to create an indirect context when creating a direct context failed. glXCreateNewContext() should return an indirect context when a direct context cannot be created.
2013-03-11 15:19:45 +00:00
glXDestroyContext(display(), ctx);
ctx = 0;
return false;
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
}
kwin: Simplify GLXBackend::initRenderingContext() glXCreateNewContext() is supposed to return NULL on failure, so let's assume that it does. Don't try to create an indirect context when creating a direct context failed. glXCreateNewContext() should return an indirect context when a direct context cannot be created.
2013-03-11 15:19:45 +00:00
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
return true;
}
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
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
bool GlxBackend::initBuffer()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
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
if (!initFbConfig())
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
return false;
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
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
if (overlayWindow()->create()) {
// Try to create double-buffered window in the overlay
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
XVisualInfo* visual = glXGetVisualFromFBConfig(display(), fbconfig);
Make kwin not crash under qemu due to failing glx call This fixes a kwin crash that happened under qemu when running kwin for the first time (subsequent runs had glx already disabled)
2013-09-17 16:07:17 +00:00
if (!visual) {
Merge branch 'master' into frameworks-scratch Conflicts: CMakeLists.txt kwin/client.cpp kwin/effects/highlightwindow/highlightwindow.cpp kwin/libkwineffects/kwingltexture.cpp kwin/libkwineffects/kwinxrenderutils.cpp kwin/scene_opengl.cpp kwin/workspace.cpp plasma/desktop/applets/kickoff/CMakeLists.txt plasma/desktop/applets/taskmanager/package/contents/code/tools.js plasma/desktop/applets/taskmanager/package/contents/ui/Task.qml plasma/desktop/applets/taskmanager/package/contents/ui/main.qml plasma/desktop/applets/taskmanager/package/metadata.desktop plasma/desktop/applets/taskmanager/plugin/textlabel.h plasma/desktop/applets/tasks/CMakeLists.txt plasma/desktop/applets/tasks/package/metadata.desktop plasma/desktop/applets/tasks/tasks.cpp plasma/desktop/toolboxes/plasma-toolbox-desktoptoolbox.desktop plasma/generic/applets/activitybar/activitybar.cpp plasma/generic/wallpapers/color/plasma-wallpaper-color.desktop plasma/generic/wallpapers/image/plasma-wallpaper-image.desktop
2013-09-24 09:28:38 +00:00
qCritical() << "Failed to get visual from fbconfig";
Make kwin not crash under qemu due to failing glx call This fixes a kwin crash that happened under qemu when running kwin for the first time (subsequent runs had glx already disabled)
2013-09-17 16:07:17 +00:00
return false;
}
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
XSetWindowAttributes attrs;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
attrs.colormap = XCreateColormap(display(), rootWindow(), visual->visual, AllocNone);
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 = XCreateWindow(display(), overlayWindow()->window(), 0, 0, displayWidth(), displayHeight(),
0, visual->depth, InputOutput, visual->visual, CWColormap, &attrs);
glxWindow = glXCreateWindow(display(), fbconfig, window, NULL);
overlayWindow()->setup(window);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
XFree(visual);
} else {
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qCritical() << "Failed to create overlay window";
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
return false;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
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
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
int vis_buffer;
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
glXGetFBConfigAttrib(display(), fbconfig, GLX_VISUAL_ID, &vis_buffer);
XVisualInfo* visinfo_buffer = glXGetVisualFromFBConfig(display(), fbconfig);
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "Buffer visual (depth " << visinfo_buffer->depth << "): 0x" << QString::number(vis_buffer, 16);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
XFree(visinfo_buffer);
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
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
return true;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
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 GlxBackend::initFbConfig()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
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
const int attribs[] = {
Fix typo Makes KWin work with NVIDIA again.
2013-03-21 11:40:49 +00:00
GLX_RENDER_TYPE, GLX_RGBA_BIT,
Explicitly request a Window-drawable REVIEW: 115937
2014-02-21 16:42:40 +00:00
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
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
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_ALPHA_SIZE, 0,
GLX_DEPTH_SIZE, 0,
GLX_STENCIL_SIZE, 0,
GLX_CONFIG_CAVEAT, GLX_NONE,
GLX_DOUBLEBUFFER, true,
0
};
// Try to find a double buffered configuration
int count = 0;
GLXFBConfig *configs = glXChooseFBConfig(display(), DefaultScreen(display()), attribs, &count);
kwin/glx: Avoid MSAA configs in initBufferConfigs() It appears that we're accidentally choosing an MSAA config with the Intel driver in Mesa 9.0. So change the algorithm to take the values of GLX_SAMPLES and GLX_SAMPLE_BUFFERS into account. Found by Kenneth Graunke.
2012-10-30 17:20:00 +00:00
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
if (count > 0) {
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
fbconfig = configs[0];
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
XFree(configs);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
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
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
if (fbconfig == NULL) {
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qCritical() << "Failed to find a usable framebuffer configuration";
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
return false;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
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
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
return true;
}
Move glx and egl code into own files
2010-11-21 13:01:39 +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
void GlxBackend::initVisualDepthHashTable()
{
const xcb_setup_t *setup = xcb_get_setup(connection());
for (auto screen = xcb_setup_roots_iterator(setup); screen.rem; xcb_screen_next(&screen)) {
for (auto depth = xcb_screen_allowed_depths_iterator(screen.data); depth.rem; xcb_depth_next(&depth)) {
const int len = xcb_depth_visuals_length(depth.data);
const xcb_visualtype_t *visuals = xcb_depth_visuals(depth.data);
for (int i = 0; i < len; i++)
m_visualDepthHash.insert(visuals[i].visual_id, depth.data->depth);
}
}
}
int GlxBackend::visualDepth(xcb_visualid_t visual) const
{
return m_visualDepthHash.value(visual);
}
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 *GlxBackend::infoForVisual(xcb_visualid_t visual)
{
FBConfigInfo *&info = m_fbconfigHash[visual];
if (info)
return info;
info = new FBConfigInfo;
info->fbconfig = nullptr;
info->bind_texture_format = 0;
info->texture_targets = 0;
info->y_inverted = 0;
info->mipmap = 0;
const xcb_render_pictformat_t format = XRenderUtils::findPictFormat(visual);
const xcb_render_directformat_t *direct = XRenderUtils::findPictFormatInfo(format);
if (!direct) {
qCritical().nospace() << "Could not find a picture format for visual 0x" << hex << visual;
return info;
}
const int red_bits = bitCount(direct->red_mask);
const int green_bits = bitCount(direct->green_mask);
const int blue_bits = bitCount(direct->blue_mask);
const int alpha_bits = bitCount(direct->alpha_mask);
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
const int depth = visualDepth(visual);
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
const auto rgb_sizes = std::tie(red_bits, green_bits, blue_bits);
const int attribs[] = {
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT | GLX_PIXMAP_BIT,
GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
GLX_X_RENDERABLE, True,
GLX_CONFIG_CAVEAT, int(GLX_DONT_CARE), // The ARGB32 visual is marked non-conformant in Catalyst
GLX_BUFFER_SIZE, red_bits + green_bits + blue_bits + alpha_bits,
GLX_RED_SIZE, red_bits,
GLX_GREEN_SIZE, green_bits,
GLX_BLUE_SIZE, blue_bits,
GLX_ALPHA_SIZE, alpha_bits,
GLX_STENCIL_SIZE, 0,
GLX_DEPTH_SIZE, 0,
0
};
int count = 0;
GLXFBConfig *configs = glXChooseFBConfig(display(), DefaultScreen(display()), attribs, &count);
if (count < 1) {
qCritical().nospace() << "Could not find a framebuffer configuration for visual 0x" << hex << visual;
return info;
}
for (int i = 0; i < count; i++) {
int red, green, blue;
glXGetFBConfigAttrib(display(), configs[i], GLX_RED_SIZE, &red);
glXGetFBConfigAttrib(display(), configs[i], GLX_GREEN_SIZE, &green);
glXGetFBConfigAttrib(display(), configs[i], GLX_BLUE_SIZE, &blue);
if (std::tie(red, green, blue) != rgb_sizes)
continue;
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
xcb_visualid_t visual;
glXGetFBConfigAttrib(display(), configs[i], GLX_VISUAL_ID, (int *) &visual);
if (visualDepth(visual) != depth)
continue;
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
int bind_rgb, bind_rgba;
glXGetFBConfigAttrib(display(), configs[i], GLX_BIND_TO_TEXTURE_RGBA_EXT, &bind_rgba);
glXGetFBConfigAttrib(display(), configs[i], GLX_BIND_TO_TEXTURE_RGB_EXT, &bind_rgb);
if (!bind_rgb && !bind_rgba)
continue;
int texture_format;
if (alpha_bits)
texture_format = bind_rgba ? GLX_TEXTURE_FORMAT_RGBA_EXT : GLX_TEXTURE_FORMAT_RGB_EXT;
else
texture_format = bind_rgb ? GLX_TEXTURE_FORMAT_RGB_EXT : GLX_TEXTURE_FORMAT_RGBA_EXT;
int y_inverted, texture_targets;
glXGetFBConfigAttrib(display(), configs[i], GLX_BIND_TO_TEXTURE_TARGETS_EXT, &texture_targets);
glXGetFBConfigAttrib(display(), configs[i], GLX_Y_INVERTED_EXT, &y_inverted);
info->fbconfig = configs[i];
info->bind_texture_format = texture_format;
info->texture_targets = texture_targets;
info->y_inverted = y_inverted;
info->mipmap = 0;
break;
}
if (count > 0)
XFree(configs);
if (info->fbconfig) {
int fbc_id = 0;
int visual_id = 0;
glXGetFBConfigAttrib(display(), info->fbconfig, GLX_FBCONFIG_ID, &fbc_id);
glXGetFBConfigAttrib(display(), info->fbconfig, GLX_VISUAL_ID, &visual_id);
qDebug().nospace() << "Using FBConfig 0x" << hex << fbc_id << " for visual 0x" << hex << visual_id;
}
return info;
}
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
void GlxBackend::setSwapInterval(int interval)
{
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
if (m_haveEXTSwapControl)
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
glXSwapIntervalEXT(display(), glxWindow, interval);
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
else if (m_haveMESASwapControl)
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
glXSwapIntervalMESA(interval);
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
else if (m_haveSGISwapControl)
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
glXSwapIntervalSGI(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
void GlxBackend::waitSync()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
// NOTE that vsync has no effect with indirect rendering
hasWaitSync -> blocksForRetrace and syncsToVBlank since that's not the same. also autodetect triple buffering REVIEW: 109783
2013-03-28 20:52:26 +00:00
if (haveWaitSync) {
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
uint sync;
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
#if 0
// TODO: why precisely is this important?
// the sync counter /can/ perform multiple steps during glXGetVideoSync & glXWaitVideoSync
// but this only leads to waiting for two frames??!?
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetVideoSync(&sync);
glXWaitVideoSync(2, (sync + 1) % 2, &sync);
fix conditional glXSwapInterval usage and cleanup profiling relics REVIEW: 105632 BUG: 303397
2012-07-17 23:50:43 +00:00
#else
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
glXWaitVideoSyncSGI(1, 0, &sync);
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
#endif
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
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
void GlxBackend::present()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
manage triple buffering REVIEW: 110556
2013-03-28 21:26:47 +00:00
if (lastDamage().isEmpty())
return;
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
const QRegion displayRegion(0, 0, displayWidth(), displayHeight());
merge buffer_age render into general render code avoiding the blocking swapinterval detection causes issues in the timing strategy and prevents protection against CPU overload on the nvidia blob BUG: 329821 FIXED-IN: 4.11.6 REVIEW: 115306
2014-01-24 21:29:30 +00:00
const bool fullRepaint = supportsBufferAge() || (lastDamage() == displayRegion);
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
if (fullRepaint) {
if (haveSwapInterval) {
hasWaitSync -> blocksForRetrace and syncsToVBlank since that's not the same. also autodetect triple buffering REVIEW: 109783
2013-03-28 20:52:26 +00:00
if (gs_tripleBufferNeedsDetection) {
glXWaitGL();
m_swapProfiler.begin();
}
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
glXSwapBuffers(display(), glxWindow);
hasWaitSync -> blocksForRetrace and syncsToVBlank since that's not the same. also autodetect triple buffering REVIEW: 109783
2013-03-28 20:52:26 +00:00
if (gs_tripleBufferNeedsDetection) {
glXWaitGL();
if (char result = m_swapProfiler.end()) {
gs_tripleBufferUndetected = gs_tripleBufferNeedsDetection = false;
prevent yield/swap cpu overhead on nvidia CCBUG: 322060 REVIEW: 111663
2013-07-23 20:34:41 +00:00
if (result == 'd' && GLPlatform::instance()->driver() == Driver_NVidia) {
// TODO this is a workaround, we should get __GL_YIELD set before libGL checks it
if (qstrcmp(qgetenv("__GL_YIELD"), "USLEEP")) {
options->setGlPreferBufferSwap(0);
setSwapInterval(0);
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qWarning() << "\nIt seems you are using the nvidia driver without triple buffering\n"
prevent yield/swap cpu overhead on nvidia CCBUG: 322060 REVIEW: 111663
2013-07-23 20:34:41 +00:00
"You must export __GL_YIELD=\"USLEEP\" to prevent large CPU overhead on synced swaps\n"
"Preferably, enable the TripleBuffer Option in the xorg.conf Device\n"
"For this reason, the tearing prevention has been disabled.\n"
"See https://bugs.kde.org/show_bug.cgi?id=322060\n";
}
}
hasWaitSync -> blocksForRetrace and syncsToVBlank since that's not the same. also autodetect triple buffering REVIEW: 109783
2013-03-28 20:52:26 +00:00
setBlocksForRetrace(result == 'd');
}
}
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
} else {
manage triple buffering REVIEW: 110556
2013-03-28 21:26:47 +00:00
waitSync();
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
glXSwapBuffers(display(), glxWindow);
}
merge buffer_age render into general render code avoiding the blocking swapinterval detection causes issues in the timing strategy and prevents protection against CPU overload on the nvidia blob BUG: 329821 FIXED-IN: 4.11.6 REVIEW: 115306
2014-01-24 21:29:30 +00:00
if (supportsBufferAge()) {
glXQueryDrawable(display(), glxWindow, GLX_BACK_BUFFER_AGE_EXT, (GLuint *) &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
} else if (m_haveMESACopySubBuffer) {
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
foreach (const QRect & r, lastDamage().rects()) {
// convert to OpenGL coordinates
int y = displayHeight() - r.y() - r.height();
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
glXCopySubBufferMESA(display(), glxWindow, r.x(), y, r.width(), r.height());
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
}
move the "copy pixels" code into its own function (it's used twice)
2013-03-22 11:17:58 +00:00
} else { // Copy Pixels (horribly slow on Mesa)
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
glDrawBuffer(GL_FRONT);
move the "copy pixels" code into its own function (it's used twice)
2013-03-22 11:17:58 +00:00
SceneOpenGL::copyPixels(lastDamage());
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
glDrawBuffer(GL_BACK);
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
}
Re-add code I accidentally removed
2013-03-26 20:49:59 +00:00
setLastDamage(QRegion());
merge buffer_age render into general render code avoiding the blocking swapinterval detection causes issues in the timing strategy and prevents protection against CPU overload on the nvidia blob BUG: 329821 FIXED-IN: 4.11.6 REVIEW: 115306
2014-01-24 21:29:30 +00:00
if (!supportsBufferAge()) {
glXWaitGL();
XFlush(display());
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
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
void GlxBackend::screenGeometryChanged(const QSize &size)
change geometry w/o compositor restart This possibly fails on some (older?) ati chip/driver combos -> Waiting for bugreports REVIEW: 103246
2011-11-26 15:15:46 +00:00
{
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
doneCurrent();
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
XMoveResizeWindow(display(), window, 0, 0, size.width(), size.height());
overlayWindow()->setup(window);
Port remainind XSync calls to XCB variant
2013-09-10 09:03:28 +00:00
Xcb::sync();
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
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
makeCurrent();
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
glViewport(0, 0, size.width(), size.height());
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
// The back buffer contents are now undefined
m_bufferAge = 0;
change geometry w/o compositor restart This possibly fails on some (older?) ati chip/driver combos -> Waiting for bugreports REVIEW: 103246
2011-11-26 15:15:46 +00:00
}
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
SceneOpenGL::TexturePrivate *GlxBackend::createBackendTexture(SceneOpenGL::Texture *texture)
{
return new GlxTexture(texture, this);
}
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
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
QRegion GlxBackend::prepareRenderingFrame()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
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
QRegion repaint;
fix scheduling the repaints repaints caused by effects so far polluted the timing calculations since they started the timer on the old vsync offset This (together with undercut timing) lead to multiple frames in the buffer queue, and ultimately to a blocking swap For unsynced painting, it simply caused wrong timings - leading to "well, kinda around 60Hz - could be 75 as just well". REVIEW: 112368 CCBUG: 322060 that part is fixed in 4.11.2
2013-08-29 23:30:13 +00:00
if (gs_tripleBufferNeedsDetection) {
// the composite timer floors the repaint frequency. This can pollute our triple buffering
// detection because the glXSwapBuffers call for the new frame has to wait until the pending
// one scanned out.
// So we compensate for that by waiting an extra milisecond to give the driver the chance to
// fllush the buffer queue
usleep(1000);
}
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
manage triple buffering REVIEW: 110556
2013-03-28 21:26:47 +00:00
present();
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
if (supportsBufferAge())
repaint = accumulatedDamageHistory(m_bufferAge);
manage triple buffering REVIEW: 110556
2013-03-28 21:26:47 +00:00
startRenderTimer();
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
glXWaitX();
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
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
return repaint;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
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
void GlxBackend::endRenderingFrame(const QRegion &renderedRegion, const QRegion &damagedRegion)
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: 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
if (damagedRegion.isEmpty()) {
setLastDamage(QRegion());
// If the damaged region of a window is fully occluded, the only
// rendering done, if any, will have been to repair a reused back
// buffer, making it identical to the front buffer.
//
// In this case we won't post the back buffer. Instead we'll just
// set the buffer age to 1, so the repaired regions won't be
// rendered again in the next frame.
if (!renderedRegion.isEmpty())
glFlush();
m_bufferAge = 1;
return;
}
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
setLastDamage(renderedRegion);
kwin: Don't call glFlush() unnecessarily in endRenderingFrame() We should only call glFlush() here if we're deferring the posting of the back buffer to the next prepareRenderingFrame() call.
2013-11-21 09:38:16 +00:00
manage triple buffering REVIEW: 110556
2013-03-28 21:26:47 +00:00
if (!blocksForRetrace()) {
kwin: Don't call glFlush() unnecessarily in endRenderingFrame() We should only call glFlush() here if we're deferring the posting of the back buffer to the next prepareRenderingFrame() call.
2013-11-21 09:38:16 +00:00
// This also sets lastDamage to empty which prevents the frame from
// being posted again when prepareRenderingFrame() is called.
present();
} else {
// Make sure that the GPU begins processing the command stream
// now and not the next time prepareRenderingFrame() is called.
glFlush();
manage triple buffering REVIEW: 110556
2013-03-28 21:26:47 +00:00
}
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
if (overlayWindow()->window()) // show the window only after the first pass,
overlayWindow()->show(); // since that pass may take long
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
// Save the damaged region to history
if (supportsBufferAge())
addToDamageHistory(damagedRegion);
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
}
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
bool GlxBackend::makeCurrent()
{
if (QOpenGLContext *context = QOpenGLContext::currentContext()) {
// Workaround to tell Qt that no QOpenGLContext is current
context->doneCurrent();
}
const bool current = glXMakeCurrent(display(), glxWindow, ctx);
return current;
}
void GlxBackend::doneCurrent()
{
glXMakeCurrent(display(), None, nullptr);
}
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
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
OverlayWindow* GlxBackend::overlayWindow()
{
return m_overlayWindow;
}
bool GlxBackend::usesOverlayWindow() const
{
return 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
/********************************************************
* GlxTexture
*******************************************************/
GlxTexture::GlxTexture(SceneOpenGL::Texture *texture, GlxBackend *backend)
: SceneOpenGL::TexturePrivate()
, q(texture)
, m_backend(backend)
, m_glxpixmap(None)
{
}
GlxTexture::~GlxTexture()
kwin: Implement "use by value" and implicit sharing for GLTexture. Additionally: - hide the GLTexture implementation using dpointers - drop the unused function SceneOpenGL::Texture::optimizeBindDamage() - Texture::load now loads a new texture and does not update the existing one REVIEW: 101999
2011-07-18 15:55:39 +00:00
{
if (m_glxpixmap != None) {
Refactoring of KWin::Options: getter methods instead of public variables
2012-02-20 09:25:13 +00:00
if (!options->isGlStrictBinding()) {
kwin: Implement "use by value" and implicit sharing for GLTexture. Additionally: - hide the GLTexture implementation using dpointers - drop the unused function SceneOpenGL::Texture::optimizeBindDamage() - Texture::load now loads a new texture and does not update the existing one REVIEW: 101999
2011-07-18 15:55:39 +00:00
glXReleaseTexImageEXT(display(), m_glxpixmap, GLX_FRONT_LEFT_EXT);
Fix a merge regression in Texture::release. Seems to be a lost change caused by rebasing moved code.
2011-02-05 10:55:10 +00:00
}
kwin: Implement "use by value" and implicit sharing for GLTexture. Additionally: - hide the GLTexture implementation using dpointers - drop the unused function SceneOpenGL::Texture::optimizeBindDamage() - Texture::load now loads a new texture and does not update the existing one REVIEW: 101999
2011-07-18 15:55:39 +00:00
glXDestroyPixmap(display(), m_glxpixmap);
kwin: fix graphical glitches for the nvidia blob This is a perliminary fix. Should be fixed properly once we have a real statemachine.
2011-08-25 08:29:23 +00:00
m_glxpixmap = None;
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
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
void GlxTexture::onDamage()
{
if (options->isGlStrictBinding() && m_glxpixmap) {
glXReleaseTexImageEXT(display(), m_glxpixmap, GLX_FRONT_LEFT_EXT);
glXBindTexImageEXT(display(), m_glxpixmap, GLX_FRONT_LEFT_EXT, NULL);
}
GLTexturePrivate::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
bool GlxTexture::loadTexture(xcb_pixmap_t pixmap, const QSize &size, xcb_visualid_t visual)
{
if (pixmap == XCB_NONE || size.isEmpty() || visual == XCB_NONE)
return false;
const FBConfigInfo *info = m_backend->infoForVisual(visual);
if (!info || info->fbconfig == nullptr)
return false;
if ((info->texture_targets & GLX_TEXTURE_2D_BIT_EXT) &&
(GLTexture::NPOTTextureSupported() ||
(isPowerOfTwo(size.width()) && isPowerOfTwo(size.height())))) {
m_target = GL_TEXTURE_2D;
m_scale.setWidth(1.0f / m_size.width());
m_scale.setHeight(1.0f / m_size.height());
} else {
assert(info->texture_targets & GLX_TEXTURE_RECTANGLE_BIT_EXT);
m_target = GL_TEXTURE_RECTANGLE;
m_scale.setWidth(1.0f);
m_scale.setHeight(1.0f);
}
const int attrs[] = {
GLX_TEXTURE_FORMAT_EXT, info->bind_texture_format,
GLX_MIPMAP_TEXTURE_EXT, info->mipmap,
GLX_TEXTURE_TARGET_EXT, m_target == GL_TEXTURE_2D ? GLX_TEXTURE_2D_EXT : GLX_TEXTURE_RECTANGLE_EXT,
0
};
m_glxpixmap = glXCreatePixmap(display(), info->fbconfig, pixmap, attrs);
m_size = size;
m_yInverted = info->y_inverted ? true : false;
m_canUseMipmaps = info->mipmap;
glGenTextures(1, &m_texture);
q->setDirty();
q->setFilter(info->mipmap > 0 ? GL_NEAREST_MIPMAP_LINEAR : GL_NEAREST);
glBindTexture(m_target, m_texture);
glXBindTexImageEXT(display(), m_glxpixmap, GLX_FRONT_LEFT_EXT, nullptr);
updateMatrix();
return 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
OpenGLBackend *GlxTexture::backend()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
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
return m_backend;
kwin: improving the texture update handling This patch changes the behavior of strictly bound textures such that they are only updated if the corresponding window has been damaged. Additionally GLTexture now keeps track of the current filter and wrapmode setting. REVIEW: 103655
2012-01-07 11:12:29 +00:00
}
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
Reference in a new issue Copy permalink