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

665 lines
24 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)
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
, drawable(None)
, fbconfig_db(NULL)
, fbconfig_nondb(NULL)
, fbconfig(NULL)
, glxDrawable(None)
, ctx(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);
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
if (ctx)
glXDestroyContext(display(), ctx);
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()) {
kwin: Remove some left over support for GLX < 1.3 We require GLX_EXT_texture_from_pixmap which in turn requires GLX 1.3.
2013-03-11 15:07:04 +00:00
if (glxDrawable)
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
glXDestroyWindow(display(), glxDrawable);
if (drawable)
XDestroyWindow(display(), drawable);
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 15:14:23 +00:00
overlayWindow()->destroy();
} else {
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
if (glxDrawable)
glXDestroyPixmap(display(), glxDrawable);
Initialize some variables and check on destruction BUG: 313911 REVIEW: 108604
2013-01-26 15:05:51 +00:00
if (gcroot)
XFreeGC(display(), gcroot);
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
if (drawable)
XFreePixmap(display(), drawable);
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 15:14:23 +00:00
}
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()) {
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
if (glXGetVideoSync && haveSwapInterval && glXIsDirect(display(), ctx)) {
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);
support a permanent glSwapBuffer either by - forcing fullrepaints unconditionally - turning a repaint to a full one beyond a threshhold - completing the the backbuffer from the frontbuffer after the paint BUG: 307965 FIXED-IN: 4.10 REVIEW: 107198
2013-02-18 22:17:46 +00:00
setSwapInterval(1);
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" <<
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
bool(glXGetVideoSync) << haveSwapInterval << glXIsDirect(display(), ctx);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Add support for OpenGL in VirtualBox OpenGL is properly working if there is a direct rendering context. If LIBGL_ALWAYS_INDIRECT is set VirtualBox falls back to Mesa's software rasterizer. So in order to get OpenGL the driver is now whitelisted in the opengltest. GLPlatform is extended to recognize the VirtualBox driver and has new methods to report whether it is a virtual machine and VirtualBox. The detection is rather limited as we don't get access to the underlying hardware, so we do not know whether the features are really supported. We need to trust the driver here in announcing the right extensions. The driver does not provide glxQueryDrawable although it is part of GLX 1.3. A hack is added in the glxbackend to set the function pointer to NULL. This can unfortunately not be done in glxResolveFunctions() as QueryDrawable seems not to be provided by an extension (at least not listed in the OpenGL registry) and getProcAddress resolves a function but it only prints an OpenGL Warning to stderr. As a note: the driver reports that it is using XSHM for GLX_EXT_texture_from_pixmap. REVIEW: 106821
2012-10-13 08:33:38 +00:00
if (glPlatform->isVirtualBox()) {
// VirtualBox does not support glxQueryDrawable
// this should actually be in kwinglutils_funcs, but QueryDrawable seems not to be provided by an extension
// and the GLPlatform has not been initialized at the moment when initGLX() is called.
glXQueryDrawable = NULL;
}
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
setIsDirectRendering(bool(glXIsDirect(display(), ctx)));
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
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
{
kwin: Simplify GLXBackend::initRenderingContext() glXCreateNewContext() is supposed to return NULL on failure, so let's assume that it does. Don't try to create an indirect context when creating a direct context failed. glXCreateNewContext() should return an indirect context when a direct context cannot be created.
2013-03-11 15:19:45 +00:00
bool direct = options->isGlDirect();
ctx = glXCreateNewContext(display(), fbconfig, GLX_RGBA_TYPE, NULL, direct);
if (!ctx) {
kDebug(1212) << "Failed to create an OpenGL context.";
return false;
}
if (!glXMakeCurrent(display(), glxDrawable, ctx)) {
kDebug(1212) << "Failed to make the OpenGL context current.";
glXDestroyContext(display(), ctx);
ctx = 0;
return false;
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
}
kwin: Simplify GLXBackend::initRenderingContext() glXCreateNewContext() is supposed to return NULL on failure, so let's assume that it does. Don't try to create an indirect context when creating a direct context failed. glXCreateNewContext() should return an indirect context when a direct context cannot be created.
2013-03-11 15:19:45 +00:00
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
return true;
}
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 15:14:23 +00:00
bool GlxBackend::initBuffer()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
kwin: Simplify GLXBackend::initBufferConfigs() Use glXChooseFBConfig() instead of glXGetFBConfigs(), and prefer the first usable configuration instead of the last. Also rename initBufferConfigs() to initFbConfig().
2013-03-11 15:16:05 +00:00
if (!initFbConfig())
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
return false;
kwin: Simplify GLXBackend::initBufferConfigs() Use glXChooseFBConfig() instead of glXGetFBConfigs(), and prefer the first usable configuration instead of the last. Also rename initBufferConfigs() to initFbConfig().
2013-03-11 15:16:05 +00:00
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
if (fbconfig_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
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
fbconfig = fbconfig_db;
XVisualInfo* visual = glXGetVisualFromFBConfig(display(), fbconfig);
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
XSetWindowAttributes attrs;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
attrs.colormap = XCreateColormap(display(), rootWindow(), visual->visual, AllocNone);
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
drawable = XCreateWindow(display(), overlayWindow()->window(), 0, 0, displayWidth(), displayHeight(),
0, visual->depth, InputOutput, visual->visual, CWColormap, &attrs);
kwin: Remove some left over support for GLX < 1.3 We require GLX_EXT_texture_from_pixmap which in turn requires GLX 1.3.
2013-03-11 15:07:04 +00:00
glxDrawable = glXCreateWindow(display(), fbconfig, drawable, NULL);
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
overlayWindow()->setup(drawable);
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 15:14:23 +00:00
setDoubleBuffer(true);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
XFree(visual);
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
} else if (fbconfig_nondb != NULL) {
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
// cannot get any double-buffered drawable, will double-buffer using a pixmap
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
fbconfig = fbconfig_nondb;
XVisualInfo* visual = glXGetVisualFromFBConfig(display(), fbconfig);
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);
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
drawable = XCreatePixmap(display(), rootWindow(), displayWidth(), displayHeight(),
visual->depth);
glxDrawable = glXCreatePixmap(display(), fbconfig, drawable, 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: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
glXGetFBConfigAttrib(display(), fbconfig, GLX_VISUAL_ID, &vis_buffer);
XVisualInfo* visinfo_buffer = glXGetVisualFromFBConfig(display(), fbconfig);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
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
kwin: Simplify GLXBackend::initBufferConfigs() Use glXChooseFBConfig() instead of glXGetFBConfigs(), and prefer the first usable configuration instead of the last. Also rename initBufferConfigs() to initFbConfig().
2013-03-11 15:16:05 +00:00
bool GlxBackend::initFbConfig()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
kwin: Simplify GLXBackend::initBufferConfigs() Use glXChooseFBConfig() instead of glXGetFBConfigs(), and prefer the first usable configuration instead of the last. Also rename initBufferConfigs() to initFbConfig().
2013-03-11 15:16:05 +00:00
int attribs[] = {
GLX_RENDER_TYPE, GLX_RGBA_TYPE,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_ALPHA_SIZE, 0,
GLX_DEPTH_SIZE, 0,
GLX_STENCIL_SIZE, 0,
GLX_CONFIG_CAVEAT, GLX_NONE,
GLX_DOUBLEBUFFER, true,
0
};
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
fbconfig_db = NULL;
fbconfig_nondb = NULL;
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
kwin: Simplify GLXBackend::initBufferConfigs() Use glXChooseFBConfig() instead of glXGetFBConfigs(), and prefer the first usable configuration instead of the last. Also rename initBufferConfigs() to initFbConfig().
2013-03-11 15:16:05 +00:00
// Try to find a double buffered configuration
int count = 0;
GLXFBConfig *configs = glXChooseFBConfig(display(), DefaultScreen(display()), attribs, &count);
kwin/glx: Avoid MSAA configs in initBufferConfigs() It appears that we're accidentally choosing an MSAA config with the Intel driver in Mesa 9.0. So change the algorithm to take the values of GLX_SAMPLES and GLX_SAMPLE_BUFFERS into account. Found by Kenneth Graunke.
2012-10-30 17:20:00 +00:00
kwin: Simplify GLXBackend::initBufferConfigs() Use glXChooseFBConfig() instead of glXGetFBConfigs(), and prefer the first usable configuration instead of the last. Also rename initBufferConfigs() to initFbConfig().
2013-03-11 15:16:05 +00:00
if (count > 0) {
fbconfig_db = configs[0];
XFree(configs);
}
kwin/glx: Avoid MSAA configs in initBufferConfigs() It appears that we're accidentally choosing an MSAA config with the Intel driver in Mesa 9.0. So change the algorithm to take the values of GLX_SAMPLES and GLX_SAMPLE_BUFFERS into account. Found by Kenneth Graunke.
2012-10-30 17:20:00 +00:00
kwin: Simplify GLXBackend::initBufferConfigs() Use glXChooseFBConfig() instead of glXGetFBConfigs(), and prefer the first usable configuration instead of the last. Also rename initBufferConfigs() to initFbConfig().
2013-03-11 15:16:05 +00:00
// Try to find a single buffered configuration
attribs[18] = false;
configs = glXChooseFBConfig(display(), DefaultScreen(display()), attribs, &count);
kwin/glx: Avoid MSAA configs in initBufferConfigs() It appears that we're accidentally choosing an MSAA config with the Intel driver in Mesa 9.0. So change the algorithm to take the values of GLX_SAMPLES and GLX_SAMPLE_BUFFERS into account. Found by Kenneth Graunke.
2012-10-30 17:20:00 +00:00
kwin: Simplify GLXBackend::initBufferConfigs() Use glXChooseFBConfig() instead of glXGetFBConfigs(), and prefer the first usable configuration instead of the last. Also rename initBufferConfigs() to initFbConfig().
2013-03-11 15:16:05 +00:00
if (count > 0) {
fbconfig_nondb = configs[0];
XFree(configs);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
kwin: Simplify GLXBackend::initBufferConfigs() Use glXChooseFBConfig() instead of glXGetFBConfigs(), and prefer the first usable configuration instead of the last. Also rename initBufferConfigs() to initFbConfig().
2013-03-11 15:16:05 +00:00
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
if (fbconfig_db == NULL && fbconfig_nondb == NULL) {
kwin: Simplify GLXBackend::initBufferConfigs() Use glXChooseFBConfig() instead of glXGetFBConfigs(), and prefer the first usable configuration instead of the last. Also rename initBufferConfigs() to initFbConfig().
2013-03-11 15:16:05 +00:00
kError(1212) << "Failed to find a usable framebuffer configuration";
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
return false;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
kwin: Simplify GLXBackend::initBufferConfigs() Use glXChooseFBConfig() instead of glXGetFBConfigs(), and prefer the first usable configuration instead of the last. Also rename initBufferConfigs() to initFbConfig().
2013-03-11 15:16:05 +00:00
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
return true;
}
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
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: Move some debug output to where it belongs
2013-03-11 15:10:14 +00:00
for (int i = 0; i <= 32; i++) {
if (fbcdrawableinfo[i].fbconfig == NULL)
continue;
int vis_drawable = 0;
glXGetFBConfigAttrib(display(), fbcdrawableinfo[i].fbconfig, GLX_VISUAL_ID, &vis_drawable);
kDebug(1212) << "Drawable visual (depth " << i << "): 0x" << QString::number(vis_drawable, 16);
}
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)
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
glXSwapIntervalEXT(display(), glxDrawable, interval);
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
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()) {
Get rid of the unreliable lastMask in the GL backend REVIEW: 109396
2013-03-10 21:18:30 +00:00
const QRegion displayRegion(0, 0, displayWidth(), displayHeight());
const bool fullRepaint = (lastDamage() == displayRegion);
support a permanent glSwapBuffer either by - forcing fullrepaints unconditionally - turning a repaint to a full one beyond a threshhold - completing the the backbuffer from the frontbuffer after the paint BUG: 307965 FIXED-IN: 4.10 REVIEW: 107198
2013-02-18 22:17:46 +00:00
if (fullRepaint) {
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
if (haveSwapInterval) {
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
glXSwapBuffers(display(), glxDrawable);
support a permanent glSwapBuffer either by - forcing fullrepaints unconditionally - turning a repaint to a full one beyond a threshhold - completing the the backbuffer from the frontbuffer after the paint BUG: 307965 FIXED-IN: 4.10 REVIEW: 107198
2013-02-18 22:17:46 +00:00
startRenderTimer();
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
} else {
support a permanent glSwapBuffer either by - forcing fullrepaints unconditionally - turning a repaint to a full one beyond a threshhold - completing the the backbuffer from the frontbuffer after the paint BUG: 307965 FIXED-IN: 4.10 REVIEW: 107198
2013-02-18 22:17:46 +00:00
waitSync(); // calls startRenderTimer();
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
glXSwapBuffers(display(), glxDrawable);
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
}
support a permanent glSwapBuffer either by - forcing fullrepaints unconditionally - turning a repaint to a full one beyond a threshhold - completing the the backbuffer from the frontbuffer after the paint BUG: 307965 FIXED-IN: 4.10 REVIEW: 107198
2013-02-18 22:17:46 +00:00
} else if (glXCopySubBuffer) {
waitSync();
foreach (const QRect & r, lastDamage().rects()) {
// convert to OpenGL coordinates
int y = displayHeight() - r.y() - r.height();
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
glXCopySubBuffer(display(), glxDrawable, r.x(), y, r.width(), r.height());
support a permanent glSwapBuffer either by - forcing fullrepaints unconditionally - turning a repaint to a full one beyond a threshhold - completing the the backbuffer from the frontbuffer after the paint BUG: 307965 FIXED-IN: 4.10 REVIEW: 107198
2013-02-18 22:17:46 +00:00
}
} else { // Copy Pixels
// if a shader is bound or the texture unit is enabled, copy pixels results in a black screen
// therefore unbind the shader and restore after copying the pixels
GLint shader = 0;
if (ShaderManager::instance()->isShaderBound()) {
glGetIntegerv(GL_CURRENT_PROGRAM, &shader);
glUseProgram(0);
}
bool reenableTexUnit = false;
if (glIsEnabled(GL_TEXTURE_2D)) {
glDisable(GL_TEXTURE_2D);
reenableTexUnit = true;
}
// no idea why glScissor() is used, but Compiz has it and it doesn't seem to hurt
glEnable(GL_SCISSOR_TEST);
glDrawBuffer(GL_FRONT);
waitSync();
int xpos = 0;
int ypos = 0;
foreach (const QRect & r, lastDamage().rects()) {
// 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());
glBitmap(0, 0, 0, 0, r.x() - xpos, y - ypos, NULL);
xpos = r.x();
ypos = y;
glScissor(r.x(), y, r.width(), r.height());
glCopyPixels(r.x(), y, r.width(), r.height(), GL_COLOR);
}
glBitmap(0, 0, 0, 0, -xpos, -ypos, NULL); // move position back to 0,0
glDrawBuffer(GL_BACK);
glDisable(GL_SCISSOR_TEST);
if (reenableTexUnit) {
glEnable(GL_TEXTURE_2D);
}
// rebind previously bound shader
if (ShaderManager::instance()->isShaderBound()) {
glUseProgram(shader);
}
Move glx and egl code into own files
2010-11-21 13:01:39 +00:00
}
support a permanent glSwapBuffer either by - forcing fullrepaints unconditionally - turning a repaint to a full one beyond a threshhold - completing the the backbuffer from the frontbuffer after the paint BUG: 307965 FIXED-IN: 4.10 REVIEW: 107198
2013-02-18 22:17:46 +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();
Get rid of the unreliable lastMask in the GL backend REVIEW: 109396
2013-03-10 21:18:30 +00:00
foreach (const QRect & r, lastDamage().rects())
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
XCopyArea(display(), drawable, 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
}
support a permanent glSwapBuffer either by - forcing fullrepaints unconditionally - turning a repaint to a full one beyond a threshhold - completing the the backbuffer from the frontbuffer after the paint BUG: 307965 FIXED-IN: 4.10 REVIEW: 107198
2013-02-18 22:17:46 +00:00
setLastDamage(QRegion());
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);
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
glXDestroyPixmap(display(), glxDrawable);
XFreePixmap(display(), drawable);
XVisualInfo* visual = glXGetVisualFromFBConfig(display(), fbconfig);
drawable = XCreatePixmap(display(), rootWindow(), size.width(), size.height(), visual->depth);
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
XFree(visual);
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
glxDrawable = glXCreatePixmap(display(), fbconfig, drawable, NULL);
glXMakeCurrent(display(), glxDrawable, ctx);
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
// 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 ////
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
XMoveResizeWindow(display(), drawable, 0,0, size.width(), size.height());
overlayWindow()->setup(drawable);
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 ////
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
glXMakeCurrent(display(), glxDrawable, ctx); // 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
Get rid of the unreliable lastMask in the GL backend REVIEW: 109396
2013-03-10 21:18:30 +00:00
void GlxBackend::endRenderingFrame(const QRegion &damage)
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
{
setLastDamage(damage);
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