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

731 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"
// kwin libs
#include <kwinglplatform.h>
// KDE
#include <KDE/KDebug>
#include <KDE/KXErrorHandler>
namespace KWin
{
GlxBackend::GlxBackend()
: OpenGLBackend()
Initialize some variables and check on destruction BUG: 313911 REVIEW: 108604
2013-01-26 15:05:51 +00:00
, gcroot(None)
, buffer(None)
, fbcbuffer_db(NULL)
, fbcbuffer_nondb(NULL)
, fbcbuffer(NULL)
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
, glxbuffer(None)
Initialize some variables and check on destruction BUG: 313911 REVIEW: 108604
2013-01-26 15:05:51 +00:00
, ctxbuffer(None)
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()
{
// TODO: cleanup in error case
// do cleanup after initBuffer()
cleanupGL();
glXMakeCurrent(display(), None, NULL);
Initialize some variables and check on destruction BUG: 313911 REVIEW: 108604
2013-01-26 15:05:51 +00:00
if (ctxbuffer)
glXDestroyContext(display(), ctxbuffer);
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()) {
Initialize some variables and check on destruction BUG: 313911 REVIEW: 108604
2013-01-26 15:05:51 +00:00
if (hasGLXVersion(1, 3) && glxbuffer)
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
glXDestroyWindow(display(), glxbuffer);
Initialize some variables and check on destruction BUG: 313911 REVIEW: 108604
2013-01-26 15:05:51 +00:00
if (buffer)
XDestroyWindow(display(), 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
overlayWindow()->destroy();
} else {
Initialize some variables and check on destruction BUG: 313911 REVIEW: 108604
2013-01-26 15:05:51 +00:00
if (glxbuffer)
glXDestroyPixmap(display(), glxbuffer);
if (gcroot)
XFreeGC(display(), gcroot);
if (buffer)
XFreePixmap(display(), 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
}
checkGLError("Cleanup");
}
void GlxBackend::init()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
initGLX();
Do not resolve glx functions specified in GLX 1.3 According to the OpenGL ABI for Linux GLX 1.3 is a minimum requirement. Therefore we do not need to resolve the symbols which are present in that version. KWin did always require at least 1.3, for all the resolved functions there were checks in the Scene, but they might have been incorrect. Instead now the GLX version is checked and OpenGL compositing is blocked if there is not at least GLX 1.3. REVIEW: 106704
2012-10-03 08:28:43 +00:00
// require at least GLX 1.3
if (!hasGLXVersion(1, 3)) {
setFailed("Requires at least GLX 1.3");
return;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 15:14:23 +00:00
if (!initDrawableConfigs()) {
setFailed("Could not initialize the drawable configs");
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
return;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 15:14:23 +00:00
if (!initBuffer()) {
setFailed("Could not initialize the buffer");
return;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 15:14:23 +00:00
if (!initRenderingContext()) {
setFailed("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;
}
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);
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);
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
// Check whether certain features are supported
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
haveSwapInterval = glXSwapIntervalMESA || glXSwapIntervalEXT || glXSwapIntervalSGI;
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
if (options->isGlVSync()) {
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
if (glXGetVideoSync && haveSwapInterval && glXIsDirect(display(), ctxbuffer)) {
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
unsigned int sync;
if (glXGetVideoSync(&sync) == 0) {
if (glXWaitVideoSync(1, 0, &sync) == 0) {
// NOTICE at this time we should actually check whether we can successfully
// deactivate the swapInterval "glXSwapInterval(0) == 0"
// (because we don't actually want it active unless we explicitly run a glXSwapBuffers)
// However mesa/dri will return a range error (6) because deactivating the
// swapinterval (as of today) seems completely unsupported
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
setHasWaitSync(true);
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
setSwapInterval(0);
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
}
else
qWarning() << "NO VSYNC! glXWaitVideoSync(1,0,&uint) isn't 0 but" << glXWaitVideoSync(1, 0, &sync);
} else
qWarning() << "NO VSYNC! glXGetVideoSync(&uint) isn't 0 but" << glXGetVideoSync(&sync);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
} else
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
qWarning() << "NO VSYNC! glXGetVideoSync, haveSwapInterval, glXIsDirect" <<
bool(glXGetVideoSync) << haveSwapInterval << glXIsDirect(display(), ctxbuffer);
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;
}
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
setIsDirectRendering(bool(glXIsDirect(display(), ctxbuffer)));
kDebug(1212) << "DB:" << isDoubleBuffer() << ", Direct:" << 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
{
Refactoring of KWin::Options: getter methods instead of public variables
2012-02-20 09:25:13 +00:00
bool direct_rendering = options->isGlDirect();
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
KXErrorHandler errs1;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
ctxbuffer = glXCreateNewContext(display(), fbcbuffer, GLX_RGBA_TYPE, NULL,
direct_rendering ? GL_TRUE : GL_FALSE);
bool failed = (ctxbuffer == NULL || !glXMakeCurrent(display(), glxbuffer, ctxbuffer));
if (errs1.error(true)) // always check for error( having it all in one if () could skip
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
failed = true; // it due to evaluation short-circuiting
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (failed) {
if (!direct_rendering) {
kDebug(1212).nospace() << "Couldn't initialize rendering context ("
<< KXErrorHandler::errorMessage(errs1.errorEvent()) << ")";
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
}
glXMakeCurrent(display(), None, NULL);
if (ctxbuffer != NULL)
glXDestroyContext(display(), ctxbuffer);
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
direct_rendering = false; // try again
KXErrorHandler errs2;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
ctxbuffer = glXCreateNewContext(display(), fbcbuffer, GLX_RGBA_TYPE, NULL, GL_FALSE);
bool failed = (ctxbuffer == NULL || !glXMakeCurrent(display(), glxbuffer, ctxbuffer));
if (errs2.error(true))
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
failed = true;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (failed) {
kDebug(1212).nospace() << "Couldn't initialize rendering context ("
<< KXErrorHandler::errorMessage(errs2.errorEvent()) << ")";
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
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
{
if (!initBufferConfigs())
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
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
if (fbcbuffer_db != NULL && overlayWindow()->create()) {
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
// we have overlay, try to create double-buffered window in it
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
fbcbuffer = fbcbuffer_db;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
XVisualInfo* visual = glXGetVisualFromFBConfig(display(), fbcbuffer);
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
XSetWindowAttributes attrs;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
attrs.colormap = XCreateColormap(display(), rootWindow(), visual->visual, AllocNone);
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
buffer = XCreateWindow(display(), overlayWindow()->window(), 0, 0, displayWidth(), displayHeight(),
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
0, visual->depth, InputOutput, visual->visual, CWColormap, &attrs);
if (hasGLXVersion(1, 3))
glxbuffer = glXCreateWindow(display(), fbcbuffer, buffer, NULL);
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
else
glxbuffer = 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
overlayWindow()->setup(buffer);
setDoubleBuffer(true);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
XFree(visual);
} else if (fbcbuffer_nondb != NULL) {
// cannot get any double-buffered drawable, will double-buffer using a pixmap
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
fbcbuffer = fbcbuffer_nondb;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
XVisualInfo* visual = glXGetVisualFromFBConfig(display(), fbcbuffer);
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
XGCValues gcattr;
gcattr.subwindow_mode = IncludeInferiors;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
gcroot = XCreateGC(display(), rootWindow(), GCSubwindowMode, &gcattr);
buffer = XCreatePixmap(display(), rootWindow(), displayWidth(), displayHeight(),
visual->depth);
glxbuffer = glXCreatePixmap(display(), fbcbuffer, buffer, NULL);
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
setDoubleBuffer(false);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
XFree(visual);
} else {
kError(1212) << "Couldn't create output buffer (failed to create overlay window?) !";
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
return false; // error
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
int vis_buffer;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetFBConfigAttrib(display(), fbcbuffer, GLX_VISUAL_ID, &vis_buffer);
XVisualInfo* visinfo_buffer = glXGetVisualFromFBConfig(display(), fbcbuffer);
kDebug(1212) << "Buffer visual (depth " << visinfo_buffer->depth << "): 0x" << QString::number(vis_buffer, 16);
XFree(visinfo_buffer);
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
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::initBufferConfigs()
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
int cnt;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
GLXFBConfig *fbconfigs = glXGetFBConfigs(display(), DefaultScreen(display()), &cnt);
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
fbcbuffer_db = NULL;
fbcbuffer_nondb = NULL;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
for (int i = 0; i < 2; i++) {
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
int back, stencil, depth, caveat, msaa_buffers, msaa_samples, alpha;
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
back = i > 0 ? INT_MAX : 1;
stencil = INT_MAX;
depth = INT_MAX;
caveat = INT_MAX;
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
msaa_buffers = INT_MAX;
msaa_samples = INT_MAX;
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
alpha = 0;
kwin/glx: Avoid MSAA configs in initBufferConfigs() It appears that we're accidentally choosing an MSAA config with the Intel driver in Mesa 9.0. So change the algorithm to take the values of GLX_SAMPLES and GLX_SAMPLE_BUFFERS into account. Found by Kenneth Graunke.
2012-10-30 17:20:00 +00:00
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
for (int j = 0; j < cnt; j++) {
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
XVisualInfo *vi;
int visual_depth;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
vi = glXGetVisualFromFBConfig(display(), fbconfigs[ j ]);
if (vi == NULL)
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
visual_depth = vi->depth;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
XFree(vi);
if (visual_depth != DefaultDepth(display(), DefaultScreen(display())))
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
int value;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_ALPHA_SIZE, &alpha);
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_BUFFER_SIZE, &value);
if (value != visual_depth && (value - alpha) != visual_depth)
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_RENDER_TYPE, &value);
if (!(value & GLX_RGBA_BIT))
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
int back_value;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_DOUBLEBUFFER, &back_value);
if (i > 0) {
if (back_value > back)
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
} else {
if (back_value < back)
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
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
int stencil_value;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_STENCIL_SIZE, &stencil_value);
if (stencil_value > stencil)
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
int depth_value;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_DEPTH_SIZE, &depth_value);
if (depth_value > depth)
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
int caveat_value;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_CONFIG_CAVEAT, &caveat_value);
if (caveat_value > caveat)
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
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
int msaa_buffers_value;
glXGetFBConfigAttrib(display(), fbconfigs[j], GLX_SAMPLE_BUFFERS,
&msaa_buffers_value);
if (msaa_buffers_value > msaa_buffers)
continue;
int msaa_samples_value;
glXGetFBConfigAttrib(display(), fbconfigs[j], GLX_SAMPLES,
&msaa_samples_value);
if (msaa_samples_value > msaa_samples)
continue;
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
back = back_value;
stencil = stencil_value;
depth = depth_value;
caveat = caveat_value;
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
msaa_buffers = msaa_buffers_value;
msaa_samples = msaa_samples_value;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (i > 0)
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
fbcbuffer_nondb = fbconfigs[ j ];
else
fbcbuffer_db = fbconfigs[ j ];
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
if (cnt)
XFree(fbconfigs);
if (fbcbuffer_db == NULL && fbcbuffer_nondb == NULL) {
kError(1212) << "Couldn't find framebuffer configuration for buffer!";
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
}
for (int i = 0; i <= 32; i++) {
if (fbcdrawableinfo[ i ].fbconfig == NULL)
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
int vis_drawable = 0;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetFBConfigAttrib(display(), fbcdrawableinfo[ i ].fbconfig, GLX_VISUAL_ID, &vis_drawable);
kDebug(1212) << "Drawable visual (depth " << i << "): 0x" << QString::number(vis_drawable, 16);
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
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::initDrawableConfigs()
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
int cnt;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
GLXFBConfig *fbconfigs = glXGetFBConfigs(display(), DefaultScreen(display()), &cnt);
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
for (int i = 0; i <= 32; i++) {
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
int back, stencil, depth, caveat, alpha, mipmap, rgba;
back = INT_MAX;
stencil = INT_MAX;
depth = INT_MAX;
caveat = INT_MAX;
mipmap = 0;
rgba = 0;
fbcdrawableinfo[ i ].fbconfig = NULL;
fbcdrawableinfo[ i ].bind_texture_format = 0;
fbcdrawableinfo[ i ].texture_targets = 0;
fbcdrawableinfo[ i ].y_inverted = 0;
fbcdrawableinfo[ i ].mipmap = 0;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
for (int j = 0; j < cnt; j++) {
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
XVisualInfo *vi;
int visual_depth;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
vi = glXGetVisualFromFBConfig(display(), fbconfigs[ j ]);
if (vi == NULL)
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
visual_depth = vi->depth;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
XFree(vi);
if (visual_depth != i)
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
int value;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_ALPHA_SIZE, &alpha);
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_BUFFER_SIZE, &value);
if (value != i && (value - alpha) != i)
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_RENDER_TYPE, &value);
if (!(value & GLX_RGBA_BIT))
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
Removing SHM and Fallback OpenGL Compositing modes. Our primary target is Texture From Pixmap and it is supported by all important drivers nowadays. If a driver is not able to support TFP using OpenGL at all is probably no good idea and XRender is more suited.
2011-01-30 10:55:27 +00:00
value = 0;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (i == 32) {
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_BIND_TO_TEXTURE_RGBA_EXT, &value);
if (value) {
Removing SHM and Fallback OpenGL Compositing modes. Our primary target is Texture From Pixmap and it is supported by all important drivers nowadays. If a driver is not able to support TFP using OpenGL at all is probably no good idea and XRender is more suited.
2011-01-30 10:55:27 +00:00
// TODO I think this should be set only after the config passes all tests
rgba = 1;
fbcdrawableinfo[ i ].bind_texture_format = GLX_TEXTURE_FORMAT_RGBA_EXT;
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
if (!value) {
if (rgba)
Removing SHM and Fallback OpenGL Compositing modes. Our primary target is Texture From Pixmap and it is supported by all important drivers nowadays. If a driver is not able to support TFP using OpenGL at all is probably no good idea and XRender is more suited.
2011-01-30 10:55:27 +00:00
continue;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_BIND_TO_TEXTURE_RGB_EXT, &value);
if (!value)
Removing SHM and Fallback OpenGL Compositing modes. Our primary target is Texture From Pixmap and it is supported by all important drivers nowadays. If a driver is not able to support TFP using OpenGL at all is probably no good idea and XRender is more suited.
2011-01-30 10:55:27 +00:00
continue;
fbcdrawableinfo[ i ].bind_texture_format = GLX_TEXTURE_FORMAT_RGB_EXT;
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
int back_value;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_DOUBLEBUFFER, &back_value);
if (back_value > back)
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
int stencil_value;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_STENCIL_SIZE, &stencil_value);
if (stencil_value > stencil)
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
int depth_value;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_DEPTH_SIZE, &depth_value);
if (depth_value > depth)
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
int caveat_value;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_CONFIG_CAVEAT, &caveat_value);
if (caveat_value > caveat)
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
continue;
// ok, config passed all tests, it's the best one so far
fbcdrawableinfo[ i ].fbconfig = fbconfigs[ j ];
caveat = caveat_value;
back = back_value;
stencil = stencil_value;
depth = depth_value;
remove (broken) mimpmap support check, disable use of mipmaps and align texture filter BUG: 296289 FIXED-IN: 4.9 REVIEW: 105249
2012-06-13 23:23:48 +00:00
mipmap = 0;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_BIND_TO_TEXTURE_TARGETS_EXT, &value);
Removing SHM and Fallback OpenGL Compositing modes. Our primary target is Texture From Pixmap and it is supported by all important drivers nowadays. If a driver is not able to support TFP using OpenGL at all is probably no good idea and XRender is more suited.
2011-01-30 10:55:27 +00:00
fbcdrawableinfo[ i ].texture_targets = value;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_Y_INVERTED_EXT, &value);
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
fbcdrawableinfo[ i ].y_inverted = value;
fbcdrawableinfo[ i ].mipmap = mipmap;
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
if (cnt)
XFree(fbconfigs);
if (fbcdrawableinfo[ DefaultDepth(display(), DefaultScreen(display()))].fbconfig == NULL) {
kError(1212) << "Couldn't find framebuffer configuration for default depth!";
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
}
if (fbcdrawableinfo[ 32 ].fbconfig == NULL) {
kError(1212) << "Couldn't find framebuffer configuration for depth 32 (no ARGB GLX visual)!";
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
return true;
}
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
void GlxBackend::setSwapInterval(int interval)
{
if (glXSwapIntervalEXT)
glXSwapIntervalEXT(display(), glxbuffer, interval);
else if (glXSwapIntervalMESA)
glXSwapIntervalMESA(interval);
else if (glXSwapIntervalSGI)
glXSwapIntervalSGI(interval);
}
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
#define VSYNC_DEBUG 0
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
if (waitSyncAvailable()) {
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
#if VSYNC_DEBUG
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
startRenderTimer();
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
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
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
glXWaitVideoSync(1, 0, &sync);
fix conditional glXSwapInterval usage and cleanup profiling relics REVIEW: 105632 BUG: 303397
2012-07-17 23:50:43 +00:00
#endif
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
#if VSYNC_DEBUG
fix conditional glXSwapInterval usage and cleanup profiling relics REVIEW: 105632 BUG: 303397
2012-07-17 23:50:43 +00:00
static int waitTime = 0, waitCounter = 0, doubleSyncCounter = 0;
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 (renderTime() > 11)
fix conditional glXSwapInterval usage and cleanup profiling relics REVIEW: 105632 BUG: 303397
2012-07-17 23:50:43 +00:00
++doubleSyncCounter;
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
waitTime += renderTime();
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
++waitCounter;
if (waitCounter > 99)
{
fix conditional glXSwapInterval usage and cleanup profiling relics REVIEW: 105632 BUG: 303397
2012-07-17 23:50:43 +00:00
qDebug() << "mean vsync wait time:" << float((float)waitTime / (float)waitCounter) << doubleSyncCounter << "/100";
doubleSyncCounter = waitTime = waitCounter = 0;
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
}
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
startRenderTimer(); // yes, the framerate shall be constant anyway.
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
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
#undef VSYNC_DEBUG
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
{
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 (isDoubleBuffer()) {
if (lastMask() & Scene::PAINT_SCREEN_REGION) {
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
waitSync();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (glXCopySubBuffer) {
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
foreach (const QRect & r, lastDamage().rects()) {
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
// convert to OpenGL coordinates
int y = displayHeight() - r.y() - r.height();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glXCopySubBuffer(display(), glxbuffer, r.x(), y, r.width(), r.height());
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
} else {
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
// if a shader is bound or the texture unit is enabled, copy pixels results in a black screen
Unbind shader before copying pixels to back buffer. This solves the regression with NVIDIA drivers resulting in a black screen. Apparently NVIDIA does not support glXCopySubBuffer and the copying of pixels fails with a shader bound. So unbinding the shader before copying the pixels and rebinding the shader afterwards resolves the issue. This allows to remove the temporary hack to make NVIDIA work, again.
2011-02-06 08:27:30 +00:00
// therefore unbind the shader and restore after copying the pixels
GLint shader = 0;
if (ShaderManager::instance()->isShaderBound()) {
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
glGetIntegerv(GL_CURRENT_PROGRAM, &shader);
glUseProgram(0);
}
bool reenableTexUnit = false;
if (glIsEnabled(GL_TEXTURE_2D)) {
glDisable(GL_TEXTURE_2D);
reenableTexUnit = true;
Unbind shader before copying pixels to back buffer. This solves the regression with NVIDIA drivers resulting in a black screen. Apparently NVIDIA does not support glXCopySubBuffer and the copying of pixels fails with a shader bound. So unbinding the shader before copying the pixels and rebinding the shader afterwards resolves the issue. This allows to remove the temporary hack to make NVIDIA work, again.
2011-02-06 08:27:30 +00:00
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
// no idea why glScissor() is used, but Compiz has it and it doesn't seem to hurt
glEnable(GL_SCISSOR_TEST);
glDrawBuffer(GL_FRONT);
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
int xpos = 0;
int ypos = 0;
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
foreach (const QRect & r, lastDamage().rects()) {
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
// convert to OpenGL coordinates
int y = displayHeight() - r.y() - r.height();
// Move raster position relatively using glBitmap() rather
// than using glRasterPos2f() - the latter causes drawing
// artefacts at the bottom screen edge with some gfx cards
// glRasterPos2f( r.x(), r.y() + r.height());
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glBitmap(0, 0, 0, 0, r.x() - xpos, y - ypos, NULL);
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
xpos = r.x();
ypos = y;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glScissor(r.x(), y, r.width(), r.height());
glCopyPixels(r.x(), y, r.width(), r.height(), GL_COLOR);
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
glBitmap(0, 0, 0, 0, -xpos, -ypos, NULL); // move position back to 0,0
glDrawBuffer(GL_BACK);
glDisable(GL_SCISSOR_TEST);
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
if (reenableTexUnit) {
glEnable(GL_TEXTURE_2D);
}
Unbind shader before copying pixels to back buffer. This solves the regression with NVIDIA drivers resulting in a black screen. Apparently NVIDIA does not support glXCopySubBuffer and the copying of pixels fails with a shader bound. So unbinding the shader before copying the pixels and rebinding the shader afterwards resolves the issue. This allows to remove the temporary hack to make NVIDIA work, again.
2011-02-06 08:27:30 +00:00
// rebind previously bound shader
if (ShaderManager::instance()->isShaderBound()) {
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
glUseProgram(shader);
Unbind shader before copying pixels to back buffer. This solves the regression with NVIDIA drivers resulting in a black screen. Apparently NVIDIA does not support glXCopySubBuffer and the copying of pixels fails with a shader bound. So unbinding the shader before copying the pixels and rebinding the shader afterwards resolves the issue. This allows to remove the temporary hack to make NVIDIA work, again.
2011-02-06 08:27:30 +00:00
}
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
} else {
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
if (haveSwapInterval) {
setSwapInterval(options->isGlVSync() ? 1 : 0);
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
glXSwapBuffers(display(), glxbuffer);
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
setSwapInterval(0);
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
startRenderTimer(); // this is important so we don't assume to be loosing frames in the compositor timing calculation
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
} else {
waitSync();
glXSwapBuffers(display(), glxbuffer);
}
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
glXWaitGL();
} else {
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
glXWaitGL();
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 (lastMask() & Scene::PAINT_SCREEN_REGION)
foreach (const QRect & r, lastDamage().rects())
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
XCopyArea(display(), buffer, rootWindow(), gcroot, r.x(), r.y(), r.width(), r.height(), r.x(), r.y());
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
else
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
XCopyArea(display(), buffer, rootWindow(), gcroot, 0, 0, displayWidth(), displayHeight(), 0, 0);
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
}
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
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
{
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() == None) {
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
glXMakeCurrent(display(), None, NULL);
glXDestroyPixmap(display(), glxbuffer);
XFreePixmap(display(), buffer);
XVisualInfo* visual = glXGetVisualFromFBConfig(display(), fbcbuffer);
buffer = XCreatePixmap(display(), rootWindow(), size.width(), size.height(), visual->depth);
XFree(visual);
glxbuffer = glXCreatePixmap(display(), fbcbuffer, buffer, NULL);
glXMakeCurrent(display(), glxbuffer, ctxbuffer);
// TODO: there seems some bug, some clients become black until an eg. un/remap - could be a general pixmap buffer issue, though
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
} else {
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
glXMakeCurrent(display(), None, NULL); // deactivate context ////
XMoveResizeWindow(display(), buffer, 0,0, size.width(), size.height());
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
overlayWindow()->setup(buffer);
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
XSync(display(), false); // ensure X11 stuff has applied ////
glXMakeCurrent(display(), glxbuffer, ctxbuffer); // reactivate context ////
Spellchecking SVN_SILENT
2012-08-16 06:03:07 +00:00
glViewport(0,0, size.width(), size.height()); // adjust viewport last - should btw. be superfluous on the Pixmap buffer - iirc glXCreatePixmap sets the context anyway. ////
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
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::prepareRenderingFrame()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 15:14:23 +00:00
if (!lastDamage().isEmpty())
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
present();
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 15:14:23 +00:00
glXWaitX();
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::endRenderingFrame(int mask, const QRegion &damage)
{
setLastDamage(damage);
setLastMask(mask);
glFlush();
if (overlayWindow()->window()) // show the window only after the first pass,
overlayWindow()->show(); // since that pass may take long
}
/********************************************************
* 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();
}
void GlxTexture::findTarget()
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
unsigned int new_target = 0;
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 (glXQueryDrawable && m_glxpixmap != None)
glXQueryDrawable(display(), m_glxpixmap, GLX_TEXTURE_TARGET_EXT, &new_target);
Readd the hack for Xgl in findTarget. Apparently glXQueryDrawable does not work in NVIDIA blob for binding a texture from an icon. This fixes an abort, but the root cause should be found and fixed properly.
2011-02-05 10:56:48 +00:00
// HACK: this used to be a hack for Xgl.
// without this hack the NVIDIA blob aborts when trying to bind a texture from
// a pixmap icon
if (new_target == 0) {
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 (GLTexture::NPOTTextureSupported() ||
(isPowerOfTwo(m_size.width()) && isPowerOfTwo(m_size.height()))) {
Readd the hack for Xgl in findTarget. Apparently glXQueryDrawable does not work in NVIDIA blob for binding a texture from an icon. This fixes an abort, but the root cause should be found and fixed properly.
2011-02-05 10:56:48 +00:00
new_target = GLX_TEXTURE_2D_EXT;
} else {
new_target = GLX_TEXTURE_RECTANGLE_EXT;
}
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
switch(new_target) {
case GLX_TEXTURE_2D_EXT:
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
m_target = GL_TEXTURE_2D;
m_scale.setWidth(1.0f / m_size.width());
m_scale.setHeight(1.0f / m_size.height());
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
break;
case GLX_TEXTURE_RECTANGLE_EXT:
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
m_target = GL_TEXTURE_RECTANGLE_ARB;
m_scale.setWidth(1.0f);
m_scale.setHeight(1.0f);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
break;
default:
abort();
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
bool GlxTexture::loadTexture(const Pixmap& pix, const QSize& size, int depth)
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
#ifdef CHECK_GL_ERROR
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
checkGLError("TextureLoad1");
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
#endif
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (pix == None || size.isEmpty() || depth < 1)
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
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
if (m_backend->fbcdrawableinfo[ depth ].fbconfig == NULL) {
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
kDebug(1212) << "No framebuffer configuration for depth " << depth
<< "; not binding pixmap" << endl;
Removing SHM and Fallback OpenGL Compositing modes. Our primary target is Texture From Pixmap and it is supported by all important drivers nowadays. If a driver is not able to support TFP using OpenGL at all is probably no good idea and XRender is more suited.
2011-01-30 10:55:27 +00:00
return false;
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
m_size = size;
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
// new texture, or texture contents changed; mipmaps now invalid
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
q->setDirty();
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
#ifdef CHECK_GL_ERROR
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
checkGLError("TextureLoad2");
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
#endif
Removing SHM and Fallback OpenGL Compositing modes. Our primary target is Texture From Pixmap and it is supported by all important drivers nowadays. If a driver is not able to support TFP using OpenGL at all is probably no good idea and XRender is more suited.
2011-01-30 10:55:27 +00:00
// tfp mode, simply bind the pixmap to texture
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
glGenTextures(1, &m_texture);
Removing SHM and Fallback OpenGL Compositing modes. Our primary target is Texture From Pixmap and it is supported by all important drivers nowadays. If a driver is not able to support TFP using OpenGL at all is probably no good idea and XRender is more suited.
2011-01-30 10:55:27 +00:00
// The GLX pixmap references the contents of the original pixmap, so it doesn't
// need to be recreated when the contents change.
// The texture may or may not use the same storage depending on the EXT_tfp
// implementation. When options->glStrictBinding is true, the texture uses
// a different storage and needs to be updated with a call to
// glXBindTexImageEXT() when the contents of the pixmap has changed.
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
int attrs[] = {
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_TEXTURE_FORMAT_EXT, m_backend->fbcdrawableinfo[ depth ].bind_texture_format,
GLX_MIPMAP_TEXTURE_EXT, m_backend->fbcdrawableinfo[ depth ].mipmap > 0,
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
None, None, None
};
// Specifying the texture target explicitly is reported to cause a performance
// regression with R300G (see bug #256654).
if (GLPlatform::instance()->driver() != Driver_R300G) {
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 ((m_backend->fbcdrawableinfo[ depth ].texture_targets & GLX_TEXTURE_2D_BIT_EXT) &&
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
(GLTexture::NPOTTextureSupported() ||
(isPowerOfTwo(size.width()) && isPowerOfTwo(size.height())))) {
attrs[ 4 ] = GLX_TEXTURE_TARGET_EXT;
attrs[ 5 ] = GLX_TEXTURE_2D_EXT;
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
} else if (m_backend->fbcdrawableinfo[ depth ].texture_targets & GLX_TEXTURE_RECTANGLE_BIT_EXT) {
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
attrs[ 4 ] = GLX_TEXTURE_TARGET_EXT;
attrs[ 5 ] = GLX_TEXTURE_RECTANGLE_EXT;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
}
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
m_glxpixmap = glXCreatePixmap(display(), m_backend->fbcdrawableinfo[ depth ].fbconfig, pix, attrs);
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
#ifdef CHECK_GL_ERROR
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
checkGLError("TextureLoadTFP1");
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
#endif
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
findTarget();
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
m_yInverted = m_backend->fbcdrawableinfo[ depth ].y_inverted ? true : false;
m_canUseMipmaps = m_backend->fbcdrawableinfo[ depth ].mipmap > 0;
q->setFilter(m_backend->fbcdrawableinfo[ depth ].mipmap > 0 ? GL_NEAREST_MIPMAP_LINEAR : GL_NEAREST);
glBindTexture(m_target, m_texture);
Removing SHM and Fallback OpenGL Compositing modes. Our primary target is Texture From Pixmap and it is supported by all important drivers nowadays. If a driver is not able to support TFP using OpenGL at all is probably no good idea and XRender is more suited.
2011-01-30 10:55:27 +00:00
#ifdef CHECK_GL_ERROR
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
checkGLError("TextureLoadTFP2");
Removing SHM and Fallback OpenGL Compositing modes. Our primary target is Texture From Pixmap and it is supported by all important drivers nowadays. If a driver is not able to support TFP using OpenGL at all is probably no good idea and XRender is more suited.
2011-01-30 10:55:27 +00:00
#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
glXBindTexImageEXT(display(), m_glxpixmap, GLX_FRONT_LEFT_EXT, NULL);
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
#ifdef CHECK_GL_ERROR
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
checkGLError("TextureLoad0");
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
#endif
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
unbind();
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
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