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

872 lines
28 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"
Add support for GLX_INTEL_swap_event Enable swap events and use them to defer rendering of the next frame until the last glXSwapBuffers() call has completed.
2014-08-07 12:16:35 +00:00
#include "composite.h"
Remove displayWidth and displayHeight from the compositor Instead of getting size from displayWidth() and displayHeight() use the information we have from Screens. This means there is only one place to have the information and by that we can ensure that all components use the same data to rely on. displayWidth/displayHeight seem to provide the wrong information when unplugging an output without disabling the output. This results in rendering artefacts. But KWin::Screens has the correct information available.
2014-11-25 07:40:23 +00:00
#include "screens.h"
Add support for GLX_INTEL_swap_event Enable swap events and use them to defer rendering of the next frame until the last glXSwapBuffers() call has completed.
2014-08-07 12:16:35 +00:00
#include "xcbutils.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
// 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>
Add support for GLX_INTEL_swap_event Enable swap events and use them to defer rendering of the next frame until the last glXSwapBuffers() call has completed.
2014-08-07 12:16:35 +00:00
#include <xcb/glx.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: Do additional sorting of fbconfigs Prefer configurations with smaller depth/stencil sizes.
2014-12-08 21:45:13 +00:00
#include <deque>
#include <algorithm>
Workaround for systems not yet having XCB 1.10 If the new used event types are not present, we define them. This should fix the broken build on the CI system.
2014-09-19 08:04:00 +00:00
#ifndef XCB_GLX_BUFFER_SWAP_COMPLETE
#define XCB_GLX_BUFFER_SWAP_COMPLETE 1
typedef struct xcb_glx_buffer_swap_complete_event_t {
uint8_t response_type; /**< */
uint8_t pad0; /**< */
uint16_t sequence; /**< */
uint16_t event_type; /**< */
uint8_t pad1[2]; /**< */
xcb_glx_drawable_t drawable; /**< */
uint32_t ust_hi; /**< */
uint32_t ust_lo; /**< */
uint32_t msc_hi; /**< */
uint32_t msc_lo; /**< */
uint32_t sbc; /**< */
} xcb_glx_buffer_swap_complete_event_t;
#endif
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>
Add support for GLX_INTEL_swap_event Enable swap events and use them to defer rendering of the next frame until the last glXSwapBuffers() call has completed.
2014-08-07 12:16:35 +00:00
#if __cplusplus <= 201103L
namespace std {
// C++-14
template<class T, class... Args>
unique_ptr<T> make_unique(Args&&... args) {
return unique_ptr<T>(new T(std::forward<Args>(args)...));
}
}
#endif
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
{
Add support for GLX_INTEL_swap_event Enable swap events and use them to defer rendering of the next frame until the last glXSwapBuffers() call has completed.
2014-08-07 12:16:35 +00:00
SwapEventFilter::SwapEventFilter(xcb_drawable_t drawable)
: X11EventFilter(Xcb::Extensions::self()->glxEventBase() + XCB_GLX_BUFFER_SWAP_COMPLETE),
m_drawable(drawable)
{
}
bool SwapEventFilter::event(xcb_generic_event_t *event)
{
xcb_glx_buffer_swap_complete_event_t *ev =
reinterpret_cast<xcb_glx_buffer_swap_complete_event_t *>(event);
if (ev->drawable == m_drawable) {
Compositor::self()->bufferSwapComplete();
return true;
}
return 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
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();
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();
glx: Do additional sorting of fbconfigs Prefer configurations with smaller depth/stencil sizes.
2014-12-08 21:45:13 +00:00
// Require 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
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
}
glx: Do additional sorting of fbconfigs Prefer configurations with smaller depth/stencil sizes.
2014-12-08 21:45:13 +00:00
initVisualDepthHashTable();
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
}
glx: Do additional sorting of fbconfigs Prefer configurations with smaller depth/stencil sizes.
2014-12-08 21:45:13 +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"));
Add support for GLX_INTEL_swap_event Enable swap events and use them to defer rendering of the next frame until the last glXSwapBuffers() call has completed.
2014-08-07 12:16:35 +00:00
m_haveINTELSwapEvent = hasGLExtension(QByteArrayLiteral("GLX_INTEL_swap_event"));
if (m_haveINTELSwapEvent) {
const QList<QByteArray> tokens = QByteArray(qVersion()).split('.');
uint32_t version = tokens[0].toInt() << 16 | tokens[1].toInt() << 8 | tokens[2].toInt();
// Qt 5.3 doesn't forward swap events to the native event filter
if (version < 0x00050400)
m_haveINTELSwapEvent = false;
}
if (m_haveINTELSwapEvent) {
m_swapEventFilter = std::make_unique<SwapEventFilter>(window);
glXSelectEvent(display(), glxWindow, GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK);
}
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
Introduce categorized logging for kwin core Done by Daniel Pastushchak for KDE during GCI-2014.
2014-12-05 10:42:15 +00:00
qCWarning(KWIN_CORE) << "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
Introduce categorized logging for kwin core Done by Daniel Pastushchak for KDE during GCI-2014.
2014-12-05 10:42:15 +00:00
qCWarning(KWIN_CORE) << "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;
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()) {
glx: Port GlxBackend::initBuffer() to xcb
2014-12-08 21:46:31 +00:00
xcb_connection_t * const c = connection();
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
// Try to create double-buffered window in the overlay
glx: Port GlxBackend::initBuffer() to xcb
2014-12-08 21:46:31 +00:00
xcb_visualid_t visual;
glXGetFBConfigAttrib(display(), fbconfig, GLX_VISUAL_ID, (int *) &visual);
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) {
glx: Port GlxBackend::initBuffer() to xcb
2014-12-08 21:46:31 +00:00
qCCritical(KWIN_CORE) << "The GLXFBConfig does not have an associated X visual";
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;
}
glx: Port GlxBackend::initBuffer() to xcb
2014-12-08 21:46:31 +00:00
xcb_colormap_t colormap = xcb_generate_id(c);
xcb_create_colormap(c, false, colormap, rootWindow(), visual);
const QSize size = screens()->size();
window = xcb_generate_id(c);
xcb_create_window(c, visualDepth(visual), window, overlayWindow()->window(),
0, 0, size.width(), size.height(), 0, XCB_WINDOW_CLASS_INPUT_OUTPUT,
visual, XCB_CW_COLORMAP, &colormap);
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 = glXCreateWindow(display(), fbconfig, window, NULL);
overlayWindow()->setup(window);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
} else {
Introduce categorized logging for kwin core Done by Daniel Pastushchak for KDE during GCI-2014.
2014-12-05 10:42:15 +00:00
qCCritical(KWIN_CORE) << "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
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
glx: Do additional sorting of fbconfigs Prefer configurations with smaller depth/stencil sizes.
2014-12-08 21:45:13 +00:00
struct FBConfig {
GLXFBConfig config;
int depth;
int stencil;
};
std::deque<FBConfig> candidates;
for (int i = 0; i < count; i++) {
int depth, stencil;
glXGetFBConfigAttrib(display(), configs[i], GLX_DEPTH_SIZE, &depth);
glXGetFBConfigAttrib(display(), configs[i], GLX_STENCIL_SIZE, &stencil);
candidates.emplace_back(FBConfig{configs[i], depth, stencil});
}
if (count > 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);
glx: Do additional sorting of fbconfigs Prefer configurations with smaller depth/stencil sizes.
2014-12-08 21:45:13 +00:00
std::stable_sort(candidates.begin(), candidates.end(), [](const FBConfig &left, const FBConfig &right) {
if (left.depth < right.depth)
return true;
if (left.stencil < right.stencil)
return true;
return false;
});
if (candidates.size() > 0) {
fbconfig = candidates.front().config;
glx: Improve the fbconfig debug output Provide more information than just the depth and the visual ID.
2014-12-08 21:58:20 +00:00
int fbconfig_id, visual_id, red, green, blue, alpha, depth, stencil;
glXGetFBConfigAttrib(display(), fbconfig, GLX_FBCONFIG_ID, &fbconfig_id);
glXGetFBConfigAttrib(display(), fbconfig, GLX_VISUAL_ID, &visual_id);
glXGetFBConfigAttrib(display(), fbconfig, GLX_RED_SIZE, &red);
glXGetFBConfigAttrib(display(), fbconfig, GLX_GREEN_SIZE, &green);
glXGetFBConfigAttrib(display(), fbconfig, GLX_BLUE_SIZE, &blue);
glXGetFBConfigAttrib(display(), fbconfig, GLX_ALPHA_SIZE, &alpha);
glXGetFBConfigAttrib(display(), fbconfig, GLX_DEPTH_SIZE, &depth);
glXGetFBConfigAttrib(display(), fbconfig, GLX_STENCIL_SIZE, &stencil);
qCDebug(KWIN_CORE, "Choosing GLXFBConfig %#x X visual %#x depth %d RGBA %d:%d:%d:%d ZS %d:%d",
fbconfig_id, visual_id, visualDepth(visual_id), red, green, blue, alpha, depth, stencil);
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
glx: Do additional sorting of fbconfigs Prefer configurations with smaller depth/stencil sizes.
2014-12-08 21:45:13 +00:00
if (fbconfig == nullptr) {
Introduce categorized logging for kwin core Done by Daniel Pastushchak for KDE during GCI-2014.
2014-12-05 10:42:15 +00:00
qCCritical(KWIN_CORE) << "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) {
Introduce categorized logging for kwin core Done by Daniel Pastushchak for KDE during GCI-2014.
2014-12-05 10:42:15 +00:00
qCCritical(KWIN_CORE).nospace() << "Could not find a picture format for visual 0x" << hex << 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
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) {
Introduce categorized logging for kwin core Done by Daniel Pastushchak for KDE during GCI-2014.
2014-12-05 10:42:15 +00:00
qCCritical(KWIN_CORE).nospace() << "Could not find a framebuffer configuration for visual 0x" << hex << 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
return info;
}
glx: Do additional sorting of fbconfigs Prefer configurations with smaller depth/stencil sizes.
2014-12-08 21:45:13 +00:00
struct FBConfig {
GLXFBConfig config;
int depth;
int stencil;
int format;
};
std::deque<FBConfig> candidates;
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
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;
glx: Do additional sorting of fbconfigs Prefer configurations with smaller depth/stencil sizes.
2014-12-08 21:45:13 +00:00
int depth, stencil;
glXGetFBConfigAttrib(display(), configs[i], GLX_DEPTH_SIZE, &depth);
glXGetFBConfigAttrib(display(), configs[i], GLX_STENCIL_SIZE, &stencil);
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 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;
glx: Do additional sorting of fbconfigs Prefer configurations with smaller depth/stencil sizes.
2014-12-08 21:45:13 +00:00
candidates.emplace_back(FBConfig{configs[i], depth, stencil, texture_format});
}
if (count > 0)
XFree(configs);
std::stable_sort(candidates.begin(), candidates.end(), [](const FBConfig &left, const FBConfig &right) {
if (left.depth < right.depth)
return true;
if (left.stencil < right.stencil)
return true;
return false;
});
if (candidates.size() > 0) {
const FBConfig &candidate = candidates.front();
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 y_inverted, texture_targets;
glx: Do additional sorting of fbconfigs Prefer configurations with smaller depth/stencil sizes.
2014-12-08 21:45:13 +00:00
glXGetFBConfigAttrib(display(), candidate.config, GLX_BIND_TO_TEXTURE_TARGETS_EXT, &texture_targets);
glXGetFBConfigAttrib(display(), candidate.config, GLX_Y_INVERTED_EXT, &y_inverted);
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
glx: Do additional sorting of fbconfigs Prefer configurations with smaller depth/stencil sizes.
2014-12-08 21:45:13 +00:00
info->fbconfig = candidate.config;
info->bind_texture_format = candidate.format;
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
info->texture_targets = texture_targets;
info->y_inverted = y_inverted;
info->mipmap = 0;
}
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;
Remove displayWidth and displayHeight from the compositor Instead of getting size from displayWidth() and displayHeight() use the information we have from Screens. This means there is only one place to have the information and by that we can ensure that all components use the same data to rely on. displayWidth/displayHeight seem to provide the wrong information when unplugging an output without disabling the output. This results in rendering artefacts. But KWin::Screens has the correct information available.
2014-11-25 07:40:23 +00:00
const QSize &screenSize = screens()->size();
const QRegion displayRegion(0, 0, screenSize.width(), screenSize.height());
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) {
Add support for GLX_INTEL_swap_event Enable swap events and use them to defer rendering of the next frame until the last glXSwapBuffers() call has completed.
2014-08-07 12:16:35 +00:00
if (m_haveINTELSwapEvent)
Compositor::self()->aboutToSwapBuffers();
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 (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);
Introduce categorized logging for kwin core Done by Daniel Pastushchak for KDE during GCI-2014.
2014-12-05 10:42:15 +00:00
qCWarning(KWIN_CORE) << "\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
Remove displayWidth and displayHeight from the compositor Instead of getting size from displayWidth() and displayHeight() use the information we have from Screens. This means there is only one place to have the information and by that we can ensure that all components use the same data to rely on. displayWidth/displayHeight seem to provide the wrong information when unplugging an output without disabling the output. This results in rendering artefacts. But KWin::Screens has the correct information available.
2014-11-25 07:40:23 +00:00
int y = screenSize.height() - 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;
Remove the NPOT texture support checks We require OpenGL 2.0 which always supports NPOT textures.
2014-11-22 14:53:15 +00:00
if (info->texture_targets & GLX_TEXTURE_2D_BIT_EXT) {
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
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: Don't allocate storage for mipmaps in TFP textures We never use a mipmap filter when we render windows.
2014-12-08 21:44:23 +00:00
GLX_MIPMAP_TEXTURE_EXT, false,
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
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;
glx: Don't allocate storage for mipmaps in TFP textures We never use a mipmap filter when we render windows.
2014-12-08 21:44:23 +00:00
m_canUseMipmaps = false;
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
glGenTextures(1, &m_texture);
q->setDirty();
glx: Don't allocate storage for mipmaps in TFP textures We never use a mipmap filter when we render windows.
2014-12-08 21:44:23 +00:00
q->setFilter(GL_NEAREST);
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
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