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

2574 lines
90 KiB
C++
Raw Normal View History

License cleanup - add headers where missing, be explicit about GPL being v2+ (right now it says just GPL, which according to GPL itself means any GPL). Decoration clients will come later. CCMAIL: kwin@kde.org svn path=/trunk/KDE/kdebase/workspace/; revision=742302
2007-11-27 19:40:25 +00:00
/********************************************************************
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
Copyright (C) 2009, 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
Based on glcompmgr code by Felix Bellaby.
Using code from Compiz and Beryl.
License cleanup - add headers where missing, be explicit about GPL being v2+ (right now it says just GPL, which according to GPL itself means any GPL). Decoration clients will come later. CCMAIL: kwin@kde.org svn path=/trunk/KDE/kdebase/workspace/; revision=742302
2007-11-27 19:40:25 +00:00
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/>.
*********************************************************************/
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
#include "scene_opengl.h"
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
#ifdef KWIN_HAVE_EGL
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
#include "eglonxbackend.h"
Egl Backend using a Wayland surface for rendering This backend is able to composite on a Wayland surface instead of an X11 overlay window. It can be considered as a prototype for a Wayland session compositor. For texture from X11 pixmap the backend uses XShm. This is far from optimal, but the KHR_image_pixmap extension is not available in Mesa's Wayland backend. It's a temporary solution till we have XWayland and texture from Wayland buffer. To use this backend one needs to specify the environment variable KWIN_OPENGL_INTERFACE with "egl_wayland". In future KWin should probably use this backend if the Wayland display env variable is defined. To use this setup: 1. Have a normal X-Server running on e.g. VT7 2. Start Weston on VT1 3. Start a terminal on Weston 4. start KWin with: DISPLAY=:0 KWIN_OPENGL_INTERFACE=egl_wayland kwin --replace & This should map a Wayland surface to Weston showing the content of the X setup. At the moment it's not yet possible to interact with the surface as input events are not yet recieved in the backend. There are still a lot of limitations as documented in the code.
2013-05-15 11:47:27 +00:00
// for Wayland
#include "config-workspace.h"
#ifdef WAYLAND_FOUND
#include "egl_wayland_backend.h"
#endif
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
#endif
#ifndef KWIN_HAVE_OPENGLES
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
#include "glxbackend.h"
#endif
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
#include <kwinglcolorcorrection.h>
Move kwineffects library into own directory Second part of cleaning up the lib directory: the effects library now lives in libkwineffects/ directory. For existing effects nothing changes as the install path is unchanged. The change obsoletes the lib/ directory. As glplatform.h has not yet been exported I dared to export it and adjust the places where it is used. CCMAIL: kwin@kde.org
2011-02-19 08:58:44 +00:00
#include <kwinglplatform.h>
Core profile compatible basic scene rendering. Adds a shader to render an untransformed scene. renderGLGeometry is not used any more and replaced by generated triangles stored in a GLVertexBuffer. The GLVertexBuffer has a new attribute to decide whether a core profile compatible rendering has to be performed. Currently windows and EffectFrames can make use of the new shader. The shader contains a debug mode which colours all rendered fragments in green. It is currently enabled in scene_opengl. Rendering transformed geometries (without shader) is currently broken.
2010-11-14 19:49:00 +00:00
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
#include "utils.h"
#include "client.h"
GLPlatform can recommend the compositor to use During detecting the OpenGL capabilities also a recommended compositor can be set. This recommendation is honoured by the OpenGL based compositors. That is the SceneOpenGL2 requires a recommendation for at least OpenGL2 and the SceneOpenGL1 requires at least a recommendation for OpenGL1. If the driver recommends XRender compositing the SceneOpenGL performs the existing fallback to XRender. With this recommendation the hacks in the Scene are removed, e.g. it is no longer checked whether the driver is software emulation as that is provided through the recommendation. To overrule the recommendation the environment variable KWIN_COMPOSE is extended by the values O1 and O2 to enforce either OpenGL 1 or OpenGL 2. This overwrites all other checks. As a side-effect this allows now to run KWin on the llvmpipe: LIBGL_ALWAYS_SOFTWARE=1 KWIN_COMPOSE=O2 kwin --replace & But not that I would recommend to use it :-) REVIEW: 106741
2012-10-05 16:00:49 +00:00
#include "composite.h"
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
#include "deleted.h"
#include "effects.h"
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
#include "lanczosfilter.h"
Move OverlayWindow from Workspace to its own class All the functionality of Overlay Window is moved to its own class OverlayWindow. It is created and owned by class Scene, since almost all function calls are called from this class. REVIEW: 101866
2011-07-06 09:58:23 +00:00
#include "overlaywindow.h"
Move decoration pixmap handling from Client to PaintRedirector The only task of the PaintRedirector is to redirect the painting of the window decorations into Pixmaps. So it should actually do this by also handling the four pixmaps for the decoration. This simplifies the code as all the logic concerning redirecting the painting is now grouped together. Furthermore the PaintRedirector is now a child of the decoration widget, which means it gets automatically destroyed whenever the decoration is destroyed - the Client does not have to care about it. Also the PaintRedirector gets only created if the Compositor is active as it is not needed in the non-compositing case. REVIEW: 106620
2012-09-28 09:59:42 +00:00
#include "paintredirector.h"
Split out screen handling from Workspace into own class Screens Following the approaches of other split out functionality Screens is a singleton class created by Workspace. The class takes over the responsibility for: * screenChanged signal delayed by timer * number of screens * geometry of given screen * active screen * config option for active screen follows mouse The class contains a small abstraction layer and has a concrete subclass wrapping around QDesktopWidget, but the idea is to go more low level and interact with XRandR directly to get more detailed information. All over KWin the usage from QDesktopWidget is ported over to the new Screens class. REVIEW: 109839
2013-04-03 10:19:27 +00:00
#include "screens.h"
Cleanup and reorder includes in client.h Removing the workspace include required to include it in many other places.
2013-04-26 09:52:15 +00:00
#include "workspace.h"
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
Hotfix GL crossfading Not correct crossfading Purpose of the hotfix is to manipulate opacities of the "semi-crossfaded™" pixmaps so that on a quick animation and sloppy check it looks somehow believable (instead of bumping the window to full opacity) REVIEW: 111888
2013-08-05 13:12:08 +00:00
#include <cmath>
kwin: Detect and handle graphics resets Reset compositing when the GL context state has been lost as a result of a graphics reset.
2013-05-19 14:45:06 +00:00
#include <unistd.h>
kwin: Use the new map() interface in makeDecorationArrays() Write the vertex data directly into the buffer object, instead of allocating two temporary arrays, copying the data into them, and then copying the data from arrays into the buffer object.
2012-09-18 20:24:01 +00:00
#include <stddef.h>
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
Add opengl debug checks, so that I don't have to add them everytime I need them. svn path=/trunk/KDE/kdebase/workspace/; revision=716883
2007-09-25 13:42:20 +00:00
// turns on checks for opengl errors in various places (for easier finding of them)
// normally only few of them are enabled
//#define CHECK_GL_ERROR
Funny how awesome ideas are often so awfully simple. Test whether compositing really works by simply trying to do it and test the result - create a small testing window with known content, do the same with it like with normal windows, grab the screen contents, compare with the original, doesn't match? -> fail. It still would be nice to have something similar for performance. svn path=/trunk/KDE/kdebase/workspace/; revision=854549
2008-08-29 19:02:36 +00:00
#include <qpainter.h>
Check max viewport and texture dimensions REVIEW: 106917
2012-10-16 20:41:21 +00:00
#include <QDBusConnection>
#include <QDBusConnectionInterface>
#include <QDBusInterface>
Remove not needed includes from kwineffect header files Only include what's actually needed in the headers. This causes of course some additional needed includes in some implementation files.
2013-02-26 07:02:27 +00:00
#include <QGraphicsScale>
Check max viewport and texture dimensions REVIEW: 106917
2012-10-16 20:41:21 +00:00
#include <QStringList>
Core profile compatible basic scene rendering. Adds a shader to render an untransformed scene. renderGLGeometry is not used any more and replaced by generated triangles stored in a GLVertexBuffer. The GLVertexBuffer has a new attribute to decide whether a core profile compatible rendering has to be performed. Currently windows and EffectFrames can make use of the new shader. The shader contains a debug mode which colours all rendered fragments in green. It is currently enabled in scene_opengl. Rendering transformed geometries (without shader) is currently broken.
2010-11-14 19:49:00 +00:00
#include <QVector2D>
#include <QVector4D>
Adding a generic scene shader able to handle transformation Currently only window transformations are supported.
2010-12-04 11:31:18 +00:00
#include <QMatrix4x4>
Funny how awesome ideas are often so awfully simple. Test whether compositing really works by simply trying to do it and test the result - create a small testing window with known content, do the same with it like with normal windows, grab the screen contents, compare with the original, doesn't match? -> fail. It still would be nice to have something similar for performance. svn path=/trunk/KDE/kdebase/workspace/; revision=854549
2008-08-29 19:02:36 +00:00
s/KLocale/KLocalizedString/g Many headers included KLocale to use i18n and co. But those methods are defined in KLocalizedString and not in KLocale. With KF5 klocale.h does no longer include KLocalizedString causing lots of compile errors.
2013-03-07 11:55:39 +00:00
#include <KDE/KLocalizedString>
kwin: Detect and handle graphics resets Reset compositing when the GL context state has been lost as a result of a graphics reset.
2013-05-19 14:45:06 +00:00
#include <KDE/KNotification>
Check max viewport and texture dimensions REVIEW: 106917
2012-10-16 20:41:21 +00:00
#include <KProcess>
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
namespace KWin
{
commiting http://svn.reviewboard.kde.org/r/6120/#review9304 this should improve v'syncing, maybe v'synced "smoothness" remaining and exposed issue are "dirty textures" w/o damage events (see the requst description) can be diminished by increasing MaxFPS above the fastest update (or shadowed below the slowest one) CCBUG: 258971 svn path=/trunk/KDE/kdebase/workspace/; revision=1207577
2010-12-18 16:51:43 +00:00
extern int currentRefreshRate();
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
//****************************************
// SceneOpenGL
//****************************************
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::OpenGLBackend()
: m_overlayWindow(new OverlayWindow()) // TODO: maybe create only if needed?
hasWaitSync -> blocksForRetrace and syncsToVBlank since that's not the same. also autodetect triple buffering REVIEW: 109783
2013-03-28 20:52:26 +00:00
, m_syncsToVBlank(false)
, m_blocksForRetrace(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
, m_directRendering(false)
kwin: Add support for EXT_buffer_age This patch adds support for GLX_EXT_buffer_age, and EGL_EXT_buffer_age on X11.
2013-11-21 09:44:06 +00:00
, m_haveBufferAge(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
, m_failed(false)
{
}
OpenGLBackend::~OpenGLBackend()
{
if (isFailed()) {
m_overlayWindow->destroy();
}
delete m_overlayWindow;
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +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 OpenGLBackend::setFailed(const QString &reason)
{
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qWarning() << "Creating the OpenGL rendering failed: " << reason;
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_failed = true;
}
void OpenGLBackend::idle()
{
Better handling for making the compositing OpenGL context current With QtQuick2 it's possible that the scene graph rendering context either lives in an own thread or uses the main GUI thread. In the latter case it's the same thread as our compositing OpenGL context lives in. This means our basic assumption that between two rendering passes the context stays current does not hold. The code already ensured that before we start a rendering pass the context is made current, but there are many more possible cases. If we use OpenGL in areas not triggered by the rendering loop but in response to other events the context needs to be made current. This includes the loading and unloading of effects (some effects use OpenGL in the static effect check, in the ctor and dtor), background loading of texture data, lazy loading after first usage invoked by shortcut, etc. etc. To properly handle these cases new methods are added to EffectsHandler to make the compositing OpenGL context current. These calls delegate down into the scene. On non-OpenGL scenes they are noop, but on OpenGL they go into the backend and make the context current. In addition they ensure that Qt doesn't think that it's QOpenGLContext is current by calling doneCurrent() on the QOpenGLContext::currentContext(). This unfortunately causes an additional call to makeCurrent with a null context, but there is no other way to tell Qt - it doesn't notice when a different context is made current with low level API calls. In the multi-threaded architecture this doesn't matter as ::currentContext() returns null. A short evaluation showed that a transition to QOpenGLContext doesn't seem feasible. Qt only supports either GLX or EGL while KWin supports both and when entering the transition phase for Wayland, it would become extremely tricky if our native platform is X11, but we want a Wayland EGL context. A future solution might be to have a "KWin-QPA plugin" which uses either xcb or Wayland and hides everything from Qt. The API documentation is extended to describe when the effects-framework ensures that an OpenGL context is current. The effects are changed to make the context current in cases where it's not guaranteed. This has been done by looking for creation or deletion of GLTextures and Shaders. If there are other OpenGL usages outside the rendering loop, ctor/dtor this needs to be changed, too.
2013-11-22 14:05:36 +00:00
if (hasPendingFlush()) {
effects->makeOpenGLContextCurrent();
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
present();
Better handling for making the compositing OpenGL context current With QtQuick2 it's possible that the scene graph rendering context either lives in an own thread or uses the main GUI thread. In the latter case it's the same thread as our compositing OpenGL context lives in. This means our basic assumption that between two rendering passes the context stays current does not hold. The code already ensured that before we start a rendering pass the context is made current, but there are many more possible cases. If we use OpenGL in areas not triggered by the rendering loop but in response to other events the context needs to be made current. This includes the loading and unloading of effects (some effects use OpenGL in the static effect check, in the ctor and dtor), background loading of texture data, lazy loading after first usage invoked by shortcut, etc. etc. To properly handle these cases new methods are added to EffectsHandler to make the compositing OpenGL context current. These calls delegate down into the scene. On non-OpenGL scenes they are noop, but on OpenGL they go into the backend and make the context current. In addition they ensure that Qt doesn't think that it's QOpenGLContext is current by calling doneCurrent() on the QOpenGLContext::currentContext(). This unfortunately causes an additional call to makeCurrent with a null context, but there is no other way to tell Qt - it doesn't notice when a different context is made current with low level API calls. In the multi-threaded architecture this doesn't matter as ::currentContext() returns null. A short evaluation showed that a transition to QOpenGLContext doesn't seem feasible. Qt only supports either GLX or EGL while KWin supports both and when entering the transition phase for Wayland, it would become extremely tricky if our native platform is X11, but we want a Wayland EGL context. A future solution might be to have a "KWin-QPA plugin" which uses either xcb or Wayland and hides everything from Qt. The API documentation is extended to describe when the effects-framework ensures that an OpenGL context is current. The effects are changed to make the context current in cases where it's not guaranteed. This has been done by looking for creation or deletion of GLTextures and Shaders. If there are other OpenGL usages outside the rendering loop, ctor/dtor this needs to be changed, too.
2013-11-22 14:05:36 +00:00
}
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
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
kwin: Add support for EXT_buffer_age This patch adds support for GLX_EXT_buffer_age, and EGL_EXT_buffer_age on X11.
2013-11-21 09:44:06 +00:00
void OpenGLBackend::addToDamageHistory(const QRegion &region)
{
if (m_damageHistory.count() > 10)
m_damageHistory.removeLast();
m_damageHistory.prepend(region);
}
QRegion OpenGLBackend::accumulatedDamageHistory(int bufferAge) const
{
QRegion region;
// Note: An age of zero means the buffer contents are undefined
if (bufferAge > 0 && bufferAge <= m_damageHistory.count()) {
for (int i = 0; i < bufferAge - 1; i++)
region |= m_damageHistory[i];
} else {
region = QRegion(0, 0, displayWidth(), displayHeight());
}
return region;
}
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
***********************************************/
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
SceneOpenGL::SceneOpenGL(Workspace* ws, OpenGLBackend *backend)
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
: Scene(ws)
Invert logic of init_ok in SceneOpenGL In case that one of the checks in SceneOpenGL failed the ctor of the sub-class continued and set init_ok to true although it should have been set to false. Now init_ok starts with true and if a check fails it is set to false. For 4.11 we should consider using an exception here - variables to check that init code works are just no proper solution. REVIEW: 107420
2012-11-22 14:08:48 +00:00
, init_ok(true)
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
, m_backend(backend)
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->isFailed()) {
Invert logic of init_ok in SceneOpenGL In case that one of the checks in SceneOpenGL failed the ctor of the sub-class continued and set init_ok to true although it should have been set to false. Now init_ok starts with true and if a check fails it is set to false. For 4.11 we should consider using an exception here - variables to check that init code works are just no proper solution. REVIEW: 107420
2012-11-22 14:08:48 +00:00
init_ok = 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
return;
}
Check max viewport and texture dimensions REVIEW: 106917
2012-10-16 20:41:21 +00:00
if (!viewportLimitsMatched(QSize(displayWidth(), displayHeight())))
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
// perform Scene specific checks
GLPlatform *glPlatform = GLPlatform::instance();
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
#ifndef KWIN_HAVE_OPENGLES
Fix no cast to/from ASCII intrduced issues * "" needs to be wrapped in QStringLiteral * QString::fromUtf8 needed for const char* and QByteArray * QByteArray::constData() needed to get to the const char*
2013-07-23 05:02:52 +00:00
if (!hasGLExtension(QStringLiteral("GL_ARB_texture_non_power_of_two"))
&& !hasGLExtension(QStringLiteral("GL_ARB_texture_rectangle"))) {
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qCritical() << "GL_ARB_texture_non_power_of_two and GL_ARB_texture_rectangle missing";
Invert logic of init_ok in SceneOpenGL In case that one of the checks in SceneOpenGL failed the ctor of the sub-class continued and set init_ok to true although it should have been set to false. Now init_ok starts with true and if a check fails it is set to false. For 4.11 we should consider using an exception here - variables to check that init code works are just no proper solution. REVIEW: 107420
2012-11-22 14:08:48 +00:00
init_ok = 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
return; // error
}
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
#endif
Increase runtime requirement to Mesa 8.0 Adjustment to reality. KWin has had a dependency on Mesa 8.0 for quite some time given that it is what basically all distributions ship. It is better to clearly state what is required. For KWin Mesa 8.0 is a more reliable dependency as all DRI drivers which do not support DRI2 have been removed. Packagers have been informed about this intended change some weeks ago. REVIEW: 106799
2012-10-10 06:04:36 +00:00
if (glPlatform->isMesaDriver() && glPlatform->mesaVersion() < kVersionNumber(8, 0)) {
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qCritical() << "KWin requires at least Mesa 8.0 for OpenGL compositing.";
Invert logic of init_ok in SceneOpenGL In case that one of the checks in SceneOpenGL failed the ctor of the sub-class continued and set init_ok to true although it should have been set to false. Now init_ok starts with true and if a check fails it is set to false. For 4.11 we should consider using an exception here - variables to check that init code works are just no proper solution. REVIEW: 107420
2012-11-22 14:08:48 +00:00
init_ok = 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
return;
}
#ifndef KWIN_HAVE_OPENGLES
kwin: Require Xcomposite 0.3 for OpenGL compositing Remove support for OpenGL compositing without using a composite overlay window. With this change kwin now also requires a double-buffered framebuffer configuration.
2013-03-11 15:27:24 +00:00
glDrawBuffer(GL_BACK);
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
#endif
kwin: Rename SceneOpenGL::debug to m_debug and add an accessor
2013-03-17 11:58:36 +00:00
m_debug = qstrcmp(qgetenv("KWIN_GL_DEBUG"), "1") == 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
// set strict binding
if (options->isGlStrictBindingFollowsDriver()) {
options->setGlStrictBinding(!glPlatform->supports(LooseBinding));
}
}
SceneOpenGL::~SceneOpenGL()
{
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
if (init_ok) {
// backend might be still needed for a different scene
delete m_backend;
}
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 15:14:23 +00:00
foreach (Window * w, windows) {
delete w;
}
// do cleanup after initBuffer()
SceneOpenGL::EffectFrame::cleanup();
checkGLError("Cleanup");
}
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
SceneOpenGL *SceneOpenGL::createScene()
{
OpenGLBackend *backend = NULL;
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
OpenGLPlatformInterface platformInterface = NoOpenGLPlatformInterface;
// should we use glx?
#ifndef KWIN_HAVE_OPENGLES
// on OpenGL we default to glx
platformInterface = GlxPlatformInterface;
#endif
Egl Backend using a Wayland surface for rendering This backend is able to composite on a Wayland surface instead of an X11 overlay window. It can be considered as a prototype for a Wayland session compositor. For texture from X11 pixmap the backend uses XShm. This is far from optimal, but the KHR_image_pixmap extension is not available in Mesa's Wayland backend. It's a temporary solution till we have XWayland and texture from Wayland buffer. To use this backend one needs to specify the environment variable KWIN_OPENGL_INTERFACE with "egl_wayland". In future KWin should probably use this backend if the Wayland display env variable is defined. To use this setup: 1. Have a normal X-Server running on e.g. VT7 2. Start Weston on VT1 3. Start a terminal on Weston 4. start KWin with: DISPLAY=:0 KWIN_OPENGL_INTERFACE=egl_wayland kwin --replace & This should map a Wayland surface to Weston showing the content of the X setup. At the moment it's not yet possible to interact with the surface as input events are not yet recieved in the backend. There are still a lot of limitations as documented in the code.
2013-05-15 11:47:27 +00:00
const QByteArray envOpenGLInterface(qgetenv("KWIN_OPENGL_INTERFACE"));
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
#ifdef KWIN_HAVE_EGL
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
#ifdef KWIN_HAVE_OPENGLES
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
// for OpenGL ES we need to use the Egl Backend
platformInterface = EglPlatformInterface;
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
#else
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
// check environment variable
Egl Backend using a Wayland surface for rendering This backend is able to composite on a Wayland surface instead of an X11 overlay window. It can be considered as a prototype for a Wayland session compositor. For texture from X11 pixmap the backend uses XShm. This is far from optimal, but the KHR_image_pixmap extension is not available in Mesa's Wayland backend. It's a temporary solution till we have XWayland and texture from Wayland buffer. To use this backend one needs to specify the environment variable KWIN_OPENGL_INTERFACE with "egl_wayland". In future KWin should probably use this backend if the Wayland display env variable is defined. To use this setup: 1. Have a normal X-Server running on e.g. VT7 2. Start Weston on VT1 3. Start a terminal on Weston 4. start KWin with: DISPLAY=:0 KWIN_OPENGL_INTERFACE=egl_wayland kwin --replace & This should map a Wayland surface to Weston showing the content of the X setup. At the moment it's not yet possible to interact with the surface as input events are not yet recieved in the backend. There are still a lot of limitations as documented in the code.
2013-05-15 11:47:27 +00:00
if (qstrcmp(envOpenGLInterface, "egl") == 0 ||
qstrcmp(envOpenGLInterface, "egl_wayland") == 0) {
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "Forcing EGL native interface through environment variable";
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
platformInterface = EglPlatformInterface;
}
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
#endif
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
#endif
switch (platformInterface) {
case GlxPlatformInterface:
#ifndef KWIN_HAVE_OPENGLES
backend = new GlxBackend();
#endif
break;
case EglPlatformInterface:
#ifdef KWIN_HAVE_EGL
Egl Backend using a Wayland surface for rendering This backend is able to composite on a Wayland surface instead of an X11 overlay window. It can be considered as a prototype for a Wayland session compositor. For texture from X11 pixmap the backend uses XShm. This is far from optimal, but the KHR_image_pixmap extension is not available in Mesa's Wayland backend. It's a temporary solution till we have XWayland and texture from Wayland buffer. To use this backend one needs to specify the environment variable KWIN_OPENGL_INTERFACE with "egl_wayland". In future KWin should probably use this backend if the Wayland display env variable is defined. To use this setup: 1. Have a normal X-Server running on e.g. VT7 2. Start Weston on VT1 3. Start a terminal on Weston 4. start KWin with: DISPLAY=:0 KWIN_OPENGL_INTERFACE=egl_wayland kwin --replace & This should map a Wayland surface to Weston showing the content of the X setup. At the moment it's not yet possible to interact with the surface as input events are not yet recieved in the backend. There are still a lot of limitations as documented in the code.
2013-05-15 11:47:27 +00:00
#ifdef WAYLAND_FOUND
if (qstrcmp(envOpenGLInterface, "egl_wayland") == 0) {
backend = new EglWaylandBackend();
} else {
backend = new EglOnXBackend();
}
#else
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
backend = new EglOnXBackend();
Egl Backend using a Wayland surface for rendering This backend is able to composite on a Wayland surface instead of an X11 overlay window. It can be considered as a prototype for a Wayland session compositor. For texture from X11 pixmap the backend uses XShm. This is far from optimal, but the KHR_image_pixmap extension is not available in Mesa's Wayland backend. It's a temporary solution till we have XWayland and texture from Wayland buffer. To use this backend one needs to specify the environment variable KWIN_OPENGL_INTERFACE with "egl_wayland". In future KWin should probably use this backend if the Wayland display env variable is defined. To use this setup: 1. Have a normal X-Server running on e.g. VT7 2. Start Weston on VT1 3. Start a terminal on Weston 4. start KWin with: DISPLAY=:0 KWIN_OPENGL_INTERFACE=egl_wayland kwin --replace & This should map a Wayland surface to Weston showing the content of the X setup. At the moment it's not yet possible to interact with the surface as input events are not yet recieved in the backend. There are still a lot of limitations as documented in the code.
2013-05-15 11:47:27 +00:00
#endif
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
#endif
break;
default:
// no backend available
return NULL;
}
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
if (!backend || backend->isFailed()) {
delete backend;
return NULL;
}
SceneOpenGL *scene = NULL;
// first let's try an OpenGL 2 scene
if (SceneOpenGL2::supported(backend)) {
scene = new SceneOpenGL2(backend);
if (scene->initFailed()) {
delete scene;
scene = NULL;
} else {
return scene;
}
}
Introduce a build option KWIN_BUILD_OPENGL_1_COMPOSITING If the build option is enabled KWIN_HAVE_OPENGL_1 is passed as a compile flag when build against OpenGL. This compile flag is meant to replace the KWIN_HAVE_OPENGLES. So far code has been ifdefed for special behavior of OpenGL ES 2.0 and to remove fixed functionality calls which are not available in OpenGL ES 2.0. With this build flag the fixed functionality calls which are only used in the OpenGL1 Compositor can be removed and keeping the KWIN_HAVE_OPENGLES for the real differences between OpenGL 2.x and OpenGL ES 2.0. E.g. a call like glColor4f should be in an glColor4f(1.0, 1.0, 1.0, 1.0); while a call like glPolygonMode should be in an glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); Building for OpenGL ES 2.0 of course implies that KWIN_HAVE_OPENGL_1 is not defined.
2012-10-05 08:45:10 +00:00
#ifdef KWIN_HAVE_OPENGL_1
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
if (SceneOpenGL1::supported(backend)) {
scene = new SceneOpenGL1(backend);
if (scene->initFailed()) {
delete scene;
scene = NULL;
}
}
#endif
if (!scene) {
GLPlatform can recommend the compositor to use During detecting the OpenGL capabilities also a recommended compositor can be set. This recommendation is honoured by the OpenGL based compositors. That is the SceneOpenGL2 requires a recommendation for at least OpenGL2 and the SceneOpenGL1 requires at least a recommendation for OpenGL1. If the driver recommends XRender compositing the SceneOpenGL performs the existing fallback to XRender. With this recommendation the hacks in the Scene are removed, e.g. it is no longer checked whether the driver is software emulation as that is provided through the recommendation. To overrule the recommendation the environment variable KWIN_COMPOSE is extended by the values O1 and O2 to enforce either OpenGL 1 or OpenGL 2. This overwrites all other checks. As a side-effect this allows now to run KWin on the llvmpipe: LIBGL_ALWAYS_SOFTWARE=1 KWIN_COMPOSE=O2 kwin --replace & But not that I would recommend to use it :-) REVIEW: 106741
2012-10-05 16:00:49 +00:00
if (GLPlatform::instance()->recommendedCompositor() == XRenderCompositing) {
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qCritical() << "OpenGL driver recommends XRender based compositing. Falling back to XRender.";
qCritical() << "To overwrite the detection use the environment variable KWIN_COMPOSE";
qCritical() << "For more information see http://community.kde.org/KWin/Environment_Variables#KWIN_COMPOSE";
GLPlatform can recommend the compositor to use During detecting the OpenGL capabilities also a recommended compositor can be set. This recommendation is honoured by the OpenGL based compositors. That is the SceneOpenGL2 requires a recommendation for at least OpenGL2 and the SceneOpenGL1 requires at least a recommendation for OpenGL1. If the driver recommends XRender compositing the SceneOpenGL performs the existing fallback to XRender. With this recommendation the hacks in the Scene are removed, e.g. it is no longer checked whether the driver is software emulation as that is provided through the recommendation. To overrule the recommendation the environment variable KWIN_COMPOSE is extended by the values O1 and O2 to enforce either OpenGL 1 or OpenGL 2. This overwrites all other checks. As a side-effect this allows now to run KWin on the llvmpipe: LIBGL_ALWAYS_SOFTWARE=1 KWIN_COMPOSE=O2 kwin --replace & But not that I would recommend to use it :-) REVIEW: 106741
2012-10-05 16:00:49 +00:00
QTimer::singleShot(0, Compositor::self(), SLOT(fallbackToXRenderCompositing()));
}
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
delete backend;
}
return scene;
}
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 *SceneOpenGL::overlayWindow()
{
return m_backend->overlayWindow();
}
hasWaitSync -> blocksForRetrace and syncsToVBlank since that's not the same. also autodetect triple buffering REVIEW: 109783
2013-03-28 20:52:26 +00:00
bool SceneOpenGL::syncsToVBlank() const
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 15:14:23 +00:00
{
hasWaitSync -> blocksForRetrace and syncsToVBlank since that's not the same. also autodetect triple buffering REVIEW: 109783
2013-03-28 20:52:26 +00:00
return m_backend->syncsToVBlank();
}
bool SceneOpenGL::blocksForRetrace() const
{
return m_backend->blocksForRetrace();
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
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
void SceneOpenGL::idle()
{
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_backend->idle();
Swap vsync order, trade in 1frame lag REVIEW: 103058
2012-03-29 20:11:28 +00:00
Scene::idle();
}
Properly check for all needed extensions and handle gracefully absence. svn path=/trunk/KDE/kdebase/workspace/; revision=669827
2007-05-30 14:22:09 +00:00
bool SceneOpenGL::initFailed() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Properly check for all needed extensions and handle gracefully absence. svn path=/trunk/KDE/kdebase/workspace/; revision=669827
2007-05-30 14:22:09 +00:00
return !init_ok;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Properly check for all needed extensions and handle gracefully absence. svn path=/trunk/KDE/kdebase/workspace/; revision=669827
2007-05-30 14:22:09 +00:00
move the "copy pixels" code into its own function (it's used twice)
2013-03-22 11:17:58 +00:00
#ifndef KWIN_HAVE_OPENGLES
void SceneOpenGL::copyPixels(const QRegion &region)
{
foreach (const QRect &r, region.rects()) {
kwin/glx: Use glBlitFramebuffer() instead of glCopyPixels() glCopyPixels(), glRasterPos() and glBitmap() are not available in a core context.
2013-03-13 17:38:56 +00:00
const int x0 = r.x();
const int y0 = displayHeight() - r.y() - r.height();
const int x1 = r.x() + r.width();
const int y1 = displayHeight() - r.y();
move the "copy pixels" code into its own function (it's used twice)
2013-03-22 11:17:58 +00:00
kwin/glx: Use glBlitFramebuffer() instead of glCopyPixels() glCopyPixels(), glRasterPos() and glBitmap() are not available in a core context.
2013-03-13 17:38:56 +00:00
glBlitFramebuffer(x0, y0, x1, y1, x0, y0, x1, y1, GL_COLOR_BUFFER_BIT, GL_NEAREST);
move the "copy pixels" code into its own function (it's used twice)
2013-03-22 11:17:58 +00:00
}
}
#endif
kwin: Detect and handle graphics resets Reset compositing when the GL context state has been lost as a result of a graphics reset.
2013-05-19 14:45:06 +00:00
#ifndef KWIN_HAVE_OPENGLES
# define GL_GUILTY_CONTEXT_RESET_KWIN GL_GUILTY_CONTEXT_RESET_ARB
# define GL_INNOCENT_CONTEXT_RESET_KWIN GL_INNOCENT_CONTEXT_RESET_ARB
# define GL_UNKNOWN_CONTEXT_RESET_KWIN GL_UNKNOWN_CONTEXT_RESET_ARB
#else
# define GL_GUILTY_CONTEXT_RESET_KWIN GL_GUILTY_CONTEXT_RESET_EXT
# define GL_INNOCENT_CONTEXT_RESET_KWIN GL_INNOCENT_CONTEXT_RESET_EXT
# define GL_UNKNOWN_CONTEXT_RESET_KWIN GL_UNKNOWN_CONTEXT_RESET_EXT
#endif
void SceneOpenGL::handleGraphicsReset(GLenum status)
{
switch (status) {
case GL_GUILTY_CONTEXT_RESET_KWIN:
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "A graphics reset attributable to the current GL context occurred.";
kwin: Detect and handle graphics resets Reset compositing when the GL context state has been lost as a result of a graphics reset.
2013-05-19 14:45:06 +00:00
break;
case GL_INNOCENT_CONTEXT_RESET_KWIN:
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "A graphics reset not attributable to the current GL context occurred.";
kwin: Detect and handle graphics resets Reset compositing when the GL context state has been lost as a result of a graphics reset.
2013-05-19 14:45:06 +00:00
break;
case GL_UNKNOWN_CONTEXT_RESET_KWIN:
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "A graphics reset of an unknown cause occurred.";
kwin: Detect and handle graphics resets Reset compositing when the GL context state has been lost as a result of a graphics reset.
2013-05-19 14:45:06 +00:00
break;
default:
break;
}
QElapsedTimer timer;
timer.start();
// Wait until the reset is completed or max 10 seconds
while (timer.elapsed() < 10000 && glGetGraphicsResetStatus() != GL_NO_ERROR)
usleep(50);
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "Attempting to reset compositing.";
kwin: Detect and handle graphics resets Reset compositing when the GL context state has been lost as a result of a graphics reset.
2013-05-19 14:45:06 +00:00
QMetaObject::invokeMethod(this, "resetCompositing", Qt::QueuedConnection);
Fix no cast to/from ASCII intrduced issues * "" needs to be wrapped in QStringLiteral * QString::fromUtf8 needed for const char* and QByteArray * QByteArray::constData() needed to get to the const char*
2013-07-23 05:02:52 +00:00
KNotification::event(QStringLiteral("graphicsreset"), i18n("Desktop effects were restarted due to a graphics reset"));
kwin: Detect and handle graphics resets Reset compositing when the GL context state has been lost as a result of a graphics reset.
2013-05-19 14:45:06 +00:00
}
rebase measuring to nano res + fix vsync padding REVIEW: 109784
2013-03-28 20:53:25 +00:00
qint64 SceneOpenGL::paint(QRegion damage, ToplevelList toplevels)
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
// actually paint the frame, flushed with the NEXT frame
foreach (Toplevel * c, toplevels) {
// TODO: cache the stacking_order in case it has not changed
assert(windows.contains(c));
stacking_order.append(windows[ c ]);
}
Better handling for making the compositing OpenGL context current With QtQuick2 it's possible that the scene graph rendering context either lives in an own thread or uses the main GUI thread. In the latter case it's the same thread as our compositing OpenGL context lives in. This means our basic assumption that between two rendering passes the context stays current does not hold. The code already ensured that before we start a rendering pass the context is made current, but there are many more possible cases. If we use OpenGL in areas not triggered by the rendering loop but in response to other events the context needs to be made current. This includes the loading and unloading of effects (some effects use OpenGL in the static effect check, in the ctor and dtor), background loading of texture data, lazy loading after first usage invoked by shortcut, etc. etc. To properly handle these cases new methods are added to EffectsHandler to make the compositing OpenGL context current. These calls delegate down into the scene. On non-OpenGL scenes they are noop, but on OpenGL they go into the backend and make the context current. In addition they ensure that Qt doesn't think that it's QOpenGLContext is current by calling doneCurrent() on the QOpenGLContext::currentContext(). This unfortunately causes an additional call to makeCurrent with a null context, but there is no other way to tell Qt - it doesn't notice when a different context is made current with low level API calls. In the multi-threaded architecture this doesn't matter as ::currentContext() returns null. A short evaluation showed that a transition to QOpenGLContext doesn't seem feasible. Qt only supports either GLX or EGL while KWin supports both and when entering the transition phase for Wayland, it would become extremely tricky if our native platform is X11, but we want a Wayland EGL context. A future solution might be to have a "KWin-QPA plugin" which uses either xcb or Wayland and hides everything from Qt. The API documentation is extended to describe when the effects-framework ensures that an OpenGL context is current. The effects are changed to make the context current in cases where it's not guaranteed. This has been done by looking for creation or deletion of GLTextures and Shaders. If there are other OpenGL usages outside the rendering loop, ctor/dtor this needs to be changed, too.
2013-11-22 14:05:36 +00:00
m_backend->makeCurrent();
kwin: Add support for EXT_buffer_age This patch adds support for GLX_EXT_buffer_age, and EGL_EXT_buffer_age on X11.
2013-11-21 09:44:06 +00:00
QRegion repaint = m_backend->prepareRenderingFrame();
kwin: Detect and handle graphics resets Reset compositing when the GL context state has been lost as a result of a graphics reset.
2013-05-19 14:45:06 +00:00
const GLenum status = glGetGraphicsResetStatus();
if (status != GL_NO_ERROR) {
handleGraphicsReset(status);
return 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
int mask = 0;
#ifdef CHECK_GL_ERROR
checkGLError("Paint1");
#endif
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: Add support for EXT_buffer_age This patch adds support for GLX_EXT_buffer_age, and EGL_EXT_buffer_age on X11.
2013-11-21 09:44:06 +00:00
// After this call, updateRegion will contain the damaged region in the
// back buffer. This is the region that needs to be posted to repair
// the front buffer. It doesn't include the additional damage returned
// by prepareRenderingFrame(). validRegion is the region that has been
// repainted, and may be larger than updateRegion.
QRegion updateRegion, validRegion;
paintScreen(&mask, damage, repaint, &updateRegion, &validRegion); // call generic implementation
kwin: Return the modified damage in a separate paintScreen() parameter
2013-11-23 14:08:17 +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
#ifndef KWIN_HAVE_OPENGLES
move the "copy pixels" code into its own function (it's used twice)
2013-03-22 11:17:58 +00:00
const QRegion displayRegion(0, 0, displayWidth(), displayHeight());
kwin: Return the modified damage in a separate paintScreen() parameter
2013-11-23 14:08:17 +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
// copy dirty parts from front to backbuffer
kwin: Add support for EXT_buffer_age This patch adds support for GLX_EXT_buffer_age, and EGL_EXT_buffer_age on X11.
2013-11-21 09:44:06 +00:00
if (!m_backend->supportsBufferAge() &&
options->glPreferBufferSwap() == Options::CopyFrontBuffer &&
validRegion != 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
glReadBuffer(GL_FRONT);
kwin: Return the modified damage in a separate paintScreen() parameter
2013-11-23 14:08:17 +00:00
copyPixels(displayRegion - validRegion);
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
glReadBuffer(GL_BACK);
damage = displayRegion;
}
#endif
kwin: Add support for EXT_buffer_age This patch adds support for GLX_EXT_buffer_age, and EGL_EXT_buffer_age on X11.
2013-11-21 09:44:06 +00:00
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
#ifdef CHECK_GL_ERROR
checkGLError("Paint2");
#endif
kwin: Add support for EXT_buffer_age This patch adds support for GLX_EXT_buffer_age, and EGL_EXT_buffer_age on X11.
2013-11-21 09:44:06 +00:00
m_backend->endRenderingFrame(validRegion, updateRegion);
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
// do cleanup
stacking_order.clear();
checkGLError("PostPaint");
return m_backend->renderTime();
}
kwin: Refactor the screen transformation code Move the code that computes the transformation matrix to its own method, and rewrite it to improve readability.
2011-02-17 17:37:43 +00:00
QMatrix4x4 SceneOpenGL::transformation(int mask, const ScreenPaintData &data) const
{
QMatrix4x4 matrix;
if (!(mask & PAINT_SCREEN_TRANSFORMED))
return matrix;
Replace translation by QVector3D in Screen/Window PaintData
2012-05-28 12:45:46 +00:00
matrix.translate(data.translation());
Use QGraphicsScale for scale information in ScreenPaintData
2012-05-28 10:00:31 +00:00
data.scale().applyTo(&matrix);
kwin: Refactor the screen transformation code Move the code that computes the transformation matrix to its own method, and rewrite it to improve readability.
2011-02-17 17:37:43 +00:00
Split out common part of ScreenPaintData and WindowPaintData New common d-pointered class PaintData is added which cannot be instantiated.
2012-06-02 19:54:18 +00:00
if (data.rotationAngle() == 0.0)
kwin: Refactor the screen transformation code Move the code that computes the transformation matrix to its own method, and rewrite it to improve readability.
2011-02-17 17:37:43 +00:00
return matrix;
// Apply the rotation
Replace custom RotationData with QGraphicsRotation
2012-05-27 17:28:02 +00:00
// cannot use data.rotation->applyTo(&matrix) as QGraphicsRotation uses projectedRotate to map back to 2D
Split out common part of ScreenPaintData and WindowPaintData New common d-pointered class PaintData is added which cannot be instantiated.
2012-06-02 19:54:18 +00:00
matrix.translate(data.rotationOrigin());
const QVector3D axis = data.rotationAxis();
matrix.rotate(data.rotationAngle(), axis.x(), axis.y(), axis.z());
matrix.translate(-data.rotationOrigin());
kwin: Refactor the screen transformation code Move the code that computes the transformation matrix to its own method, and rewrite it to improve readability.
2011-02-17 17:37:43 +00:00
return matrix;
}
Merge together paintBackground and paintGenericScreen
2011-01-02 08:46:30 +00:00
void SceneOpenGL::paintBackground(QRegion region)
{
PaintClipper pc(region);
if (!PaintClipper::clip()) {
glClearColor(0, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
return;
}
if (pc.clip() && pc.paintArea().isEmpty())
return; // no background to paint
QVector<float> verts;
for (PaintClipper::Iterator iterator; !iterator.isDone(); iterator.next()) {
QRect r = iterator.boundingRect();
verts << r.x() + r.width() << r.y();
verts << r.x() << r.y();
verts << r.x() << r.y() + r.height();
verts << r.x() << r.y() + r.height();
verts << r.x() + r.width() << r.y() + r.height();
verts << r.x() + r.width() << r.y();
}
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
doPaintBackground(verts);
Merge together paintBackground and paintGenericScreen
2011-01-02 08:46:30 +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
void SceneOpenGL::extendPaintRegion(QRegion &region, bool opaqueFullscreen)
{
kwin: Add support for EXT_buffer_age This patch adds support for GLX_EXT_buffer_age, and EGL_EXT_buffer_age on X11.
2013-11-21 09:44:06 +00:00
if (m_backend->supportsBufferAge())
return;
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 (options->glPreferBufferSwap() == Options::ExtendDamage) { // only Extend "large" repaints
const QRegion displayRegion(0, 0, displayWidth(), displayHeight());
uint damagedPixels = 0;
const uint fullRepaintLimit = (opaqueFullscreen?0.49f:0.748f)*displayWidth()*displayHeight();
// 16:9 is 75% of 4:3 and 2.55:1 is 49.01% of 5:4
// (5:4 is the most square format and 2.55:1 is Cinemascope55 - the widest ever shot
// movie aspect - two times ;-) It's a Fox format, though, so maybe we want to restrict
// to 2.20:1 - Panavision - which has actually been used for interesting movies ...)
// would be 57% of 5/4
foreach (const QRect &r, region.rects()) {
// damagedPixels += r.width() * r.height(); // combined window damage test
damagedPixels = r.width() * r.height(); // experimental single window damage testing
if (damagedPixels > fullRepaintLimit) {
region = displayRegion;
return;
}
}
} else if (options->glPreferBufferSwap() == Options::PaintFullScreen) { // forced full rePaint
region = QRegion(0, 0, displayWidth(), displayHeight());
}
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
void SceneOpenGL::windowAdded(Toplevel* c)
{
assert(!windows.contains(c));
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
Window *w = createWindow(c);
Make the Scene owned by the Compositor The Scene has always been created and destroyed inside what is now the split out compositor. Which means it is actually owned by the Compositor. The static pointer has never been needed inside KWin core. Access to the Scene is not required for the Window Manager. The only real usage is in the EffectsHandlerImpl and in utils.h to provide a convenient way to figure out whether compositing is currently active (scene != NULL). The EffectsHandlerImpl gets also created by the Compositor after the Scene is created and gets deleted just before the Scene gets deleted. This allows to inject the Scene into the EffectsHandlerImpl to resolve the static access in this class. The convenient way to access the compositing() in utils.h had to go. To provide the same feature the Compositor provides a hasScene() access which has the same behavior as the old method. In order to keep the code changes small in Workspace and Toplevel a new method compositing() is defined which properly resolves the state. A disadvantage is that this can no longer be inlined and consists of several method calls and pointer checks.
2012-08-16 19:19:54 +00:00
windows[ c ] = w;
w->setScene(this);
Make mothod windowGeometryShapeChanged() a slot The method windowGeometryShapeChanged() from the class Scene is now a slot. It is now connected to the signal geometryShapeChanged() which is sent from Toplevel instances Client and Unmanaged. All direct method calls were deleted.
2011-06-19 20:07:19 +00:00
connect(c, SIGNAL(geometryShapeChanged(KWin::Toplevel*,QRect)), SLOT(windowGeometryShapeChanged(KWin::Toplevel*)));
Merge signals clientClosed() and unmanagedClosed() to windowClosed() This commit merges the two signals clientClosed() and unmanagedClosed() to windowClosed() which is now provided by Toplevel. The approriate slots in effects.h and effects.cpp were merges as well, since they did the same. The direct method calls of the method windowClosed() in SceneOpenGL and SceneXRender were removed and are now connected to the appropriate signal in windowAdded().
2011-06-21 11:52:25 +00:00
connect(c, SIGNAL(windowClosed(KWin::Toplevel*,KWin::Deleted*)), SLOT(windowClosed(KWin::Toplevel*,KWin::Deleted*)));
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
c->effectWindow()->setSceneWindow(windows[ c ]);
Move ownership on Shadow from Toplevel to Scene::Window The Shadow is clearly an aspect of the compositor. Therefore the Shadow has to be owned and controlled by the Scene::Window. Nevertheless Toplevel needs to know about the Shadow cause of reading the property.
2011-04-03 09:31:33 +00:00
c->getShadow();
windows[ c ]->updateShadow(c->shadow());
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
Make Scene::windowClosed() a Q_SLOT This commit just makes the declaration of windowClosed() in Class Scene be a Q_SLOT. The inheriting classes SceneOpenGL and SceneXRender are updated as well.
2011-06-21 10:30:42 +00:00
void SceneOpenGL::windowClosed(KWin::Toplevel* c, KWin::Deleted* deleted)
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
assert(windows.contains(c));
if (deleted != NULL) {
// replace c with deleted
Window* w = windows.take(c);
w->updateToplevel(deleted);
Move ownership on Shadow from Toplevel to Scene::Window The Shadow is clearly an aspect of the compositor. Therefore the Shadow has to be owned and controlled by the Scene::Window. Nevertheless Toplevel needs to know about the Shadow cause of reading the property.
2011-04-03 09:31:33 +00:00
if (w->shadow()) {
w->shadow()->setToplevel(deleted);
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
windows[ deleted ] = w;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
} else {
delete windows.take(c);
c->effectWindow()->setSceneWindow(NULL);
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
void SceneOpenGL::windowDeleted(Deleted* c)
{
assert(windows.contains(c));
delete windows.take(c);
c->effectWindow()->setSceneWindow(NULL);
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
Make mothod windowGeometryShapeChanged() a slot The method windowGeometryShapeChanged() from the class Scene is now a slot. It is now connected to the signal geometryShapeChanged() which is sent from Toplevel instances Client and Unmanaged. All direct method calls were deleted.
2011-06-19 20:07:19 +00:00
void SceneOpenGL::windowGeometryShapeChanged(KWin::Toplevel* c)
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
if (!windows.contains(c)) // this is ok, shape is not valid
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
return; // by default
Window* w = windows[ c ];
w->discardShape();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +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::Texture *SceneOpenGL::createTexture()
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 new Texture(m_backend);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +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::Texture *SceneOpenGL::createTexture(const QPixmap &pix, GLenum target)
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
return new Texture(m_backend, pix, target);
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
}
Check max viewport and texture dimensions REVIEW: 106917
2012-10-16 20:41:21 +00:00
bool SceneOpenGL::viewportLimitsMatched(const QSize &size) const {
GLint limit[2];
glGetIntegerv(GL_MAX_VIEWPORT_DIMS, limit);
if (limit[0] < size.width() || limit[1] < size.height()) {
QMetaObject::invokeMethod(Compositor::self(), "suspend",
Qt::QueuedConnection, Q_ARG(Compositor::SuspendReason, Compositor::AllReasonSuspend));
const QString message = i18n("<h1>OpenGL desktop effects not possible</h1>"
"Your system cannot perform OpenGL Desktop Effects at the "
"current resolution<br><br>"
Fix spacing
2013-01-24 05:32:54 +00:00
"You can try to select the XRender backend, but it "
Check max viewport and texture dimensions REVIEW: 106917
2012-10-16 20:41:21 +00:00
"might be very slow for this resolution as well.<br>"
"Alternatively, lower the combined resolution of all screens "
"to %1x%2 ", limit[0], limit[1]);
const QString details = i18n("The demanded resolution exceeds the GL_MAX_VIEWPORT_DIMS "
"limitation of your GPU and is therefore not compatible "
"with the OpenGL compositor.<br>"
"XRender does not know such limitation, but the performance "
Fix spacing
2013-01-24 05:32:54 +00:00
"will usually be impacted by the hardware limitations that "
Check max viewport and texture dimensions REVIEW: 106917
2012-10-16 20:41:21 +00:00
"restrict the OpenGL viewport size.");
const int oldTimeout = QDBusConnection::sessionBus().interface()->timeout();
QDBusConnection::sessionBus().interface()->setTimeout(500);
Fix no cast to/from ASCII intrduced issues * "" needs to be wrapped in QStringLiteral * QString::fromUtf8 needed for const char* and QByteArray * QByteArray::constData() needed to get to the const char*
2013-07-23 05:02:52 +00:00
if (QDBusConnection::sessionBus().interface()->isServiceRegistered(QStringLiteral("org.kde.kwinCompositingDialog")).value()) {
QDBusInterface dialog( QStringLiteral("org.kde.kwinCompositingDialog"), QStringLiteral("/CompositorSettings"), QStringLiteral("org.kde.kwinCompositingDialog") );
dialog.asyncCall(QStringLiteral("warn"), message, details, QString());
Check max viewport and texture dimensions REVIEW: 106917
2012-10-16 20:41:21 +00:00
} else {
Fix no cast to/from ASCII intrduced issues * "" needs to be wrapped in QStringLiteral * QString::fromUtf8 needed for const char* and QByteArray * QByteArray::constData() needed to get to the const char*
2013-07-23 05:02:52 +00:00
const QString args = QStringLiteral("warn ") + QString::fromUtf8(message.toLocal8Bit().toBase64()) + QStringLiteral(" details ") + QString::fromUtf8(details.toLocal8Bit().toBase64());
KProcess::startDetached(QStringLiteral("kcmshell4"), QStringList() << QStringLiteral("kwincompositing") << QStringLiteral("--args") << args);
Check max viewport and texture dimensions REVIEW: 106917
2012-10-16 20:41:21 +00:00
}
QDBusConnection::sessionBus().interface()->setTimeout(oldTimeout);
return false;
}
glGetIntegerv(GL_MAX_TEXTURE_SIZE, limit);
if (limit[0] < size.width() || limit[0] < size.height()) {
Fix no cast to/from ASCII intrduced issues * "" needs to be wrapped in QStringLiteral * QString::fromUtf8 needed for const char* and QByteArray * QByteArray::constData() needed to get to the const char*
2013-07-23 05:02:52 +00:00
KConfig cfg(QStringLiteral("kwin_dialogsrc"));
Check max viewport and texture dimensions REVIEW: 106917
2012-10-16 20:41:21 +00:00
if (!KConfigGroup(&cfg, "Notification Messages").readEntry("max_tex_warning", true))
return true;
const QString message = i18n("<h1>OpenGL desktop effects might be unusable</h1>"
"OpenGL Desktop Effects at the current resolution are supported "
"but might be exceptionally slow.<br>"
"Also large windows will turn entirely black.<br><br>"
"Consider to suspend compositing, switch to the XRender backend "
"or lower the resolution to %1x%1." , limit[0]);
const QString details = i18n("The demanded resolution exceeds the GL_MAX_TEXTURE_SIZE "
"limitation of your GPU, thus windows of that size cannot be "
"assigned to textures and will be entirely black.<br>"
"Also this limit will often be a performance level barrier despite "
"below GL_MAX_VIEWPORT_DIMS, because the driver might fall back to "
"software rendering in this case.");
const int oldTimeout = QDBusConnection::sessionBus().interface()->timeout();
QDBusConnection::sessionBus().interface()->setTimeout(500);
Fix no cast to/from ASCII intrduced issues * "" needs to be wrapped in QStringLiteral * QString::fromUtf8 needed for const char* and QByteArray * QByteArray::constData() needed to get to the const char*
2013-07-23 05:02:52 +00:00
if (QDBusConnection::sessionBus().interface()->isServiceRegistered(QStringLiteral("org.kde.kwinCompositingDialog")).value()) {
QDBusInterface dialog( QStringLiteral("org.kde.kwinCompositingDialog"), QStringLiteral("/CompositorSettings"), QStringLiteral("org.kde.kwinCompositingDialog") );
dialog.asyncCall(QStringLiteral("warn"), message, details, QStringLiteral("kwin_dialogsrc:max_tex_warning"));
Check max viewport and texture dimensions REVIEW: 106917
2012-10-16 20:41:21 +00:00
} else {
Fix no cast to/from ASCII intrduced issues * "" needs to be wrapped in QStringLiteral * QString::fromUtf8 needed for const char* and QByteArray * QByteArray::constData() needed to get to the const char*
2013-07-23 05:02:52 +00:00
const QString args = QStringLiteral("warn ") + QString::fromUtf8(message.toLocal8Bit().toBase64()) + QStringLiteral(" details ") +
QString::fromUtf8(details.toLocal8Bit().toBase64()) + QStringLiteral(" dontagain kwin_dialogsrc:max_tex_warning");
KProcess::startDetached(QStringLiteral("kcmshell4"), QStringList() << QStringLiteral("kwincompositing") << QStringLiteral("--args") << args);
Check max viewport and texture dimensions REVIEW: 106917
2012-10-16 20:41:21 +00:00
}
QDBusConnection::sessionBus().interface()->setTimeout(oldTimeout);
}
return true;
}
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 15:14:23 +00:00
void SceneOpenGL::screenGeometryChanged(const QSize &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
{
Check max viewport and texture dimensions REVIEW: 106917
2012-10-16 20:41:21 +00:00
if (!viewportLimitsMatched(size))
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
Scene::screenGeometryChanged(size);
glViewport(0,0, size.width(), size.height());
m_backend->screenGeometryChanged(size);
ShaderManager::instance()->resetAllShaders();
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
}
Adding a DesktopThumbnailItem declarative item Similar to WindowThumbnailItem for rendering a desktop thumbnail. Uses the new paintDesktop hook. FEATURE: 296067 FIXED-IN: 4.11.0 REVIEW: 104441
2012-03-29 18:17:57 +00:00
void SceneOpenGL::paintDesktop(int desktop, int mask, const QRegion &region, ScreenPaintData &data)
{
const QRect r = region.boundingRect();
glEnable(GL_SCISSOR_TEST);
glScissor(r.x(), displayHeight() - r.y() - r.height(), r.width(), r.height());
KWin::Scene::paintDesktop(desktop, mask, region, data);
glDisable(GL_SCISSOR_TEST);
}
Better handling for making the compositing OpenGL context current With QtQuick2 it's possible that the scene graph rendering context either lives in an own thread or uses the main GUI thread. In the latter case it's the same thread as our compositing OpenGL context lives in. This means our basic assumption that between two rendering passes the context stays current does not hold. The code already ensured that before we start a rendering pass the context is made current, but there are many more possible cases. If we use OpenGL in areas not triggered by the rendering loop but in response to other events the context needs to be made current. This includes the loading and unloading of effects (some effects use OpenGL in the static effect check, in the ctor and dtor), background loading of texture data, lazy loading after first usage invoked by shortcut, etc. etc. To properly handle these cases new methods are added to EffectsHandler to make the compositing OpenGL context current. These calls delegate down into the scene. On non-OpenGL scenes they are noop, but on OpenGL they go into the backend and make the context current. In addition they ensure that Qt doesn't think that it's QOpenGLContext is current by calling doneCurrent() on the QOpenGLContext::currentContext(). This unfortunately causes an additional call to makeCurrent with a null context, but there is no other way to tell Qt - it doesn't notice when a different context is made current with low level API calls. In the multi-threaded architecture this doesn't matter as ::currentContext() returns null. A short evaluation showed that a transition to QOpenGLContext doesn't seem feasible. Qt only supports either GLX or EGL while KWin supports both and when entering the transition phase for Wayland, it would become extremely tricky if our native platform is X11, but we want a Wayland EGL context. A future solution might be to have a "KWin-QPA plugin" which uses either xcb or Wayland and hides everything from Qt. The API documentation is extended to describe when the effects-framework ensures that an OpenGL context is current. The effects are changed to make the context current in cases where it's not guaranteed. This has been done by looking for creation or deletion of GLTextures and Shaders. If there are other OpenGL usages outside the rendering loop, ctor/dtor this needs to be changed, too.
2013-11-22 14:05:36 +00:00
bool SceneOpenGL::makeOpenGLContextCurrent()
{
return m_backend->makeCurrent();
}
void SceneOpenGL::doneOpenGLContextCurrent()
{
m_backend->doneCurrent();
}
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
//****************************************
// SceneOpenGL2
//****************************************
bool SceneOpenGL2::supported(OpenGLBackend *backend)
{
GLPlatform can recommend the compositor to use During detecting the OpenGL capabilities also a recommended compositor can be set. This recommendation is honoured by the OpenGL based compositors. That is the SceneOpenGL2 requires a recommendation for at least OpenGL2 and the SceneOpenGL1 requires at least a recommendation for OpenGL1. If the driver recommends XRender compositing the SceneOpenGL performs the existing fallback to XRender. With this recommendation the hacks in the Scene are removed, e.g. it is no longer checked whether the driver is software emulation as that is provided through the recommendation. To overrule the recommendation the environment variable KWIN_COMPOSE is extended by the values O1 and O2 to enforce either OpenGL 1 or OpenGL 2. This overwrites all other checks. As a side-effect this allows now to run KWin on the llvmpipe: LIBGL_ALWAYS_SOFTWARE=1 KWIN_COMPOSE=O2 kwin --replace & But not that I would recommend to use it :-) REVIEW: 106741
2012-10-05 16:00:49 +00:00
const QByteArray forceEnv = qgetenv("KWIN_COMPOSE");
if (!forceEnv.isEmpty()) {
if (qstrcmp(forceEnv, "O2") == 0) {
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "OpenGL 2 compositing enforced by environment variable";
GLPlatform can recommend the compositor to use During detecting the OpenGL capabilities also a recommended compositor can be set. This recommendation is honoured by the OpenGL based compositors. That is the SceneOpenGL2 requires a recommendation for at least OpenGL2 and the SceneOpenGL1 requires at least a recommendation for OpenGL1. If the driver recommends XRender compositing the SceneOpenGL performs the existing fallback to XRender. With this recommendation the hacks in the Scene are removed, e.g. it is no longer checked whether the driver is software emulation as that is provided through the recommendation. To overrule the recommendation the environment variable KWIN_COMPOSE is extended by the values O1 and O2 to enforce either OpenGL 1 or OpenGL 2. This overwrites all other checks. As a side-effect this allows now to run KWin on the llvmpipe: LIBGL_ALWAYS_SOFTWARE=1 KWIN_COMPOSE=O2 kwin --replace & But not that I would recommend to use it :-) REVIEW: 106741
2012-10-05 16:00:49 +00:00
return true;
} else {
// OpenGL 2 disabled by environment variable
return false;
}
}
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
if (!backend->isDirectRendering()) {
return false;
}
GLPlatform can recommend the compositor to use During detecting the OpenGL capabilities also a recommended compositor can be set. This recommendation is honoured by the OpenGL based compositors. That is the SceneOpenGL2 requires a recommendation for at least OpenGL2 and the SceneOpenGL1 requires at least a recommendation for OpenGL1. If the driver recommends XRender compositing the SceneOpenGL performs the existing fallback to XRender. With this recommendation the hacks in the Scene are removed, e.g. it is no longer checked whether the driver is software emulation as that is provided through the recommendation. To overrule the recommendation the environment variable KWIN_COMPOSE is extended by the values O1 and O2 to enforce either OpenGL 1 or OpenGL 2. This overwrites all other checks. As a side-effect this allows now to run KWin on the llvmpipe: LIBGL_ALWAYS_SOFTWARE=1 KWIN_COMPOSE=O2 kwin --replace & But not that I would recommend to use it :-) REVIEW: 106741
2012-10-05 16:00:49 +00:00
if (GLPlatform::instance()->recommendedCompositor() < OpenGL2Compositing) {
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "Driver does not recommend OpenGL 2 compositing";
Do not block OpenGL 2 when build for gles due to driver recommendation Let's assume a user knows what she is doing when she selects kwin_gles instead of kwin. Also in gles there is no fallback to OpenGL 1 possible so blocking is not the proper solution in the first place. BUG: 311712 FIXED-IN: 4.10 RC 2 REVIEW: 107824
2012-12-20 20:44:10 +00:00
#ifndef KWIN_HAVE_OPENGLES
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
return false;
Do not block OpenGL 2 when build for gles due to driver recommendation Let's assume a user knows what she is doing when she selects kwin_gles instead of kwin. Also in gles there is no fallback to OpenGL 1 possible so blocking is not the proper solution in the first place. BUG: 311712 FIXED-IN: 4.10 RC 2 REVIEW: 107824
2012-12-20 20:44:10 +00:00
#endif
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
}
if (options->isGlLegacy()) {
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "OpenGL 2 disabled by config option";
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
return false;
}
return true;
}
SceneOpenGL2::SceneOpenGL2(OpenGLBackend *backend)
: SceneOpenGL(Workspace::self(), backend)
Do not use a WeakPointer for LanczosFilter No need for a WeakPointer as it's just used only in SceneOpenGL2. REVIEW: 108853
2013-02-08 11:12:51 +00:00
, m_lanczosFilter(NULL)
Only create ColorCorrection if it is enabled in the options According to massif just creating the ColorCorrection costs 2 MiB, so it makes sense to not create it if it is not used. REVIEW: 111604 DIGEST: Smaller memory footprint in KWin 4.11.2 if color correction is disabled
2013-09-04 12:42:45 +00:00
, m_colorCorrection()
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
{
Invert logic of init_ok in SceneOpenGL In case that one of the checks in SceneOpenGL failed the ctor of the sub-class continued and set init_ok to true although it should have been set to false. Now init_ok starts with true and if a check fails it is set to false. For 4.11 we should consider using an exception here - variables to check that init code works are just no proper solution. REVIEW: 107420
2012-11-22 14:08:48 +00:00
if (!init_ok) {
// base ctor already failed
return;
}
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
// Initialize color correction before the shaders
Only create ColorCorrection if it is enabled in the options According to massif just creating the ColorCorrection costs 2 MiB, so it makes sense to not create it if it is not used. REVIEW: 111604 DIGEST: Smaller memory footprint in KWin 4.11.2 if color correction is disabled
2013-09-04 12:42:45 +00:00
slotColorCorrectedChanged(false);
Abort color correction initialization and disable it in case of errors Checks are now performed for GL errors and in case of errors everything is aborted. The error handling mechanism introduced for this purpose somewhat improves the color correction code. Fix gl invalid operation in color correction, when first setting up the lookup texture uniform. REVIEW: 107754
2012-12-16 08:30:50 +00:00
connect(options, SIGNAL(colorCorrectedChanged()), this, SLOT(slotColorCorrectedChanged()), Qt::QueuedConnection);
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
if (!ShaderManager::instance()->isValid()) {
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "No Scene Shaders available";
Invert logic of init_ok in SceneOpenGL In case that one of the checks in SceneOpenGL failed the ctor of the sub-class continued and set init_ok to true although it should have been set to false. Now init_ok starts with true and if a check fails it is set to false. For 4.11 we should consider using an exception here - variables to check that init code works are just no proper solution. REVIEW: 107420
2012-11-22 14:08:48 +00:00
init_ok = false;
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
return;
}
// push one shader on the stack so that one is always bound
ShaderManager::instance()->pushShader(ShaderManager::SimpleShader);
if (checkGLError("Init")) {
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qCritical() << "OpenGL 2 compositing setup failed";
Invert logic of init_ok in SceneOpenGL In case that one of the checks in SceneOpenGL failed the ctor of the sub-class continued and set init_ok to true although it should have been set to false. Now init_ok starts with true and if a check fails it is set to false. For 4.11 we should consider using an exception here - variables to check that init code works are just no proper solution. REVIEW: 107420
2012-11-22 14:08:48 +00:00
init_ok = false;
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
return; // error
}
kwin: Create a vertex array object in SceneOpenGL2 Using a vertex array object is not optional in an OpenGL core context.
2013-03-13 16:03:30 +00:00
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "OpenGL 2 compositing successfully initialized";
kwin: Create a vertex array object in SceneOpenGL2 Using a vertex array object is not optional in an OpenGL core context.
2013-03-13 16:03:30 +00:00
#ifndef KWIN_HAVE_OPENGLES
// It is not legal to not have a vertex array object bound in a core context
Fix no cast to/from ASCII intrduced issues * "" needs to be wrapped in QStringLiteral * QString::fromUtf8 needed for const char* and QByteArray * QByteArray::constData() needed to get to the const char*
2013-07-23 05:02:52 +00:00
if (hasGLExtension(QStringLiteral("GL_ARB_vertex_array_object"))) {
kwin: Create a vertex array object in SceneOpenGL2 Using a vertex array object is not optional in an OpenGL core context.
2013-03-13 16:03:30 +00:00
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
}
#endif
init_ok = true;
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
}
SceneOpenGL2::~SceneOpenGL2()
{
}
void SceneOpenGL2::paintGenericScreen(int mask, ScreenPaintData data)
{
Introduce a helper class to automatically push/pop Shaders The ShaderBinder class can be used for the case that a block of code should be executed with a given Shader being bound. This is useful for all the cases where there is a if-block for OpenGL2 execution with a Shader being pushed in the first line to the ShaderManager and popped in the last line of the block. With the helper this can be simplified to: ShaderBinder binder(myCustomShader); or ShaderBinder binder(ShaderManager::GenericShader); The ctor of ShaderBinder pushes the given Shader to the stack and once the helper goes out of scope it will be popped again from the stack. In addition the helper can take care of OpenGL 1 compositing, that is it just does nothing. So it can also be used where there is a shared OpenGL1 and OpenGL2 code path where the Shader should only be pushed in OpenGL2. This basically removes all the checks for the compositing type before pushing/popping a Shader to the stack. REVIEW: 106521
2012-09-21 09:25:08 +00:00
ShaderBinder binder(ShaderManager::GenericShader);
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
Introduce a helper class to automatically push/pop Shaders The ShaderBinder class can be used for the case that a block of code should be executed with a given Shader being bound. This is useful for all the cases where there is a if-block for OpenGL2 execution with a Shader being pushed in the first line to the ShaderManager and popped in the last line of the block. With the helper this can be simplified to: ShaderBinder binder(myCustomShader); or ShaderBinder binder(ShaderManager::GenericShader); The ctor of ShaderBinder pushes the given Shader to the stack and once the helper goes out of scope it will be popped again from the stack. In addition the helper can take care of OpenGL 1 compositing, that is it just does nothing. So it can also be used where there is a shared OpenGL1 and OpenGL2 code path where the Shader should only be pushed in OpenGL2. This basically removes all the checks for the compositing type before pushing/popping a Shader to the stack. REVIEW: 106521
2012-09-21 09:25:08 +00:00
binder.shader()->setUniform(GLShader::ScreenTransformation, transformation(mask, data));
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
Scene::paintGenericScreen(mask, data);
}
Adding a DesktopThumbnailItem declarative item Similar to WindowThumbnailItem for rendering a desktop thumbnail. Uses the new paintDesktop hook. FEATURE: 296067 FIXED-IN: 4.11.0 REVIEW: 104441
2012-03-29 18:17:57 +00:00
void SceneOpenGL2::paintDesktop(int desktop, int mask, const QRegion &region, ScreenPaintData &data)
{
ShaderBinder binder(ShaderManager::GenericShader);
GLShader *shader = binder.shader();
QMatrix4x4 screenTransformation = shader->getUniformMatrix4x4("screenTransformation");
KWin::SceneOpenGL::paintDesktop(desktop, mask, region, data);
shader->setUniform(GLShader::ScreenTransformation, screenTransformation);
}
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
void SceneOpenGL2::doPaintBackground(const QVector< float >& vertices)
{
GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
vbo->reset();
vbo->setUseColor(true);
vbo->setData(vertices.count() / 2, 2, vertices.data(), NULL);
Introduce a helper class to automatically push/pop Shaders The ShaderBinder class can be used for the case that a block of code should be executed with a given Shader being bound. This is useful for all the cases where there is a if-block for OpenGL2 execution with a Shader being pushed in the first line to the ShaderManager and popped in the last line of the block. With the helper this can be simplified to: ShaderBinder binder(myCustomShader); or ShaderBinder binder(ShaderManager::GenericShader); The ctor of ShaderBinder pushes the given Shader to the stack and once the helper goes out of scope it will be popped again from the stack. In addition the helper can take care of OpenGL 1 compositing, that is it just does nothing. So it can also be used where there is a shared OpenGL1 and OpenGL2 code path where the Shader should only be pushed in OpenGL2. This basically removes all the checks for the compositing type before pushing/popping a Shader to the stack. REVIEW: 106521
2012-09-21 09:25:08 +00:00
ShaderBinder binder(ShaderManager::ColorShader);
binder.shader()->setUniform(GLShader::Offset, QVector2D(0, 0));
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
vbo->render(GL_TRIANGLES);
}
SceneOpenGL::Window *SceneOpenGL2::createWindow(Toplevel *t)
{
return new SceneOpenGL2Window(t);
}
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
void SceneOpenGL2::finalDrawWindow(EffectWindowImpl* w, int mask, QRegion region, WindowPaintData& data)
{
Only create ColorCorrection if it is enabled in the options According to massif just creating the ColorCorrection costs 2 MiB, so it makes sense to not create it if it is not used. REVIEW: 111604 DIGEST: Smaller memory footprint in KWin 4.11.2 if color correction is disabled
2013-09-04 12:42:45 +00:00
if (!m_colorCorrection.isNull() && m_colorCorrection->isEnabled()) {
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
// Split the painting for separate screens
Split out screen handling from Workspace into own class Screens Following the approaches of other split out functionality Screens is a singleton class created by Workspace. The class takes over the responsibility for: * screenChanged signal delayed by timer * number of screens * geometry of given screen * active screen * config option for active screen follows mouse The class contains a small abstraction layer and has a concrete subclass wrapping around QDesktopWidget, but the idea is to go more low level and interact with XRandR directly to get more detailed information. All over KWin the usage from QDesktopWidget is ported over to the new Screens class. REVIEW: 109839
2013-04-03 10:19:27 +00:00
const int numScreens = screens()->count();
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
for (int screen = 0; screen < numScreens; ++ screen) {
QRegion regionForScreen(region);
if (numScreens > 1)
Split out screen handling from Workspace into own class Screens Following the approaches of other split out functionality Screens is a singleton class created by Workspace. The class takes over the responsibility for: * screenChanged signal delayed by timer * number of screens * geometry of given screen * active screen * config option for active screen follows mouse The class contains a small abstraction layer and has a concrete subclass wrapping around QDesktopWidget, but the idea is to go more low level and interact with XRandR directly to get more detailed information. All over KWin the usage from QDesktopWidget is ported over to the new Screens class. REVIEW: 109839
2013-04-03 10:19:27 +00:00
regionForScreen = region.intersected(screens()->geometry(screen));
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
data.setScreen(screen);
performPaintWindow(w, mask, regionForScreen, data);
}
} else {
performPaintWindow(w, mask, region, data);
}
}
void SceneOpenGL2::performPaintWindow(EffectWindowImpl* w, int mask, QRegion region, WindowPaintData& data)
{
if (mask & PAINT_WINDOW_LANCZOS) {
Do not use a WeakPointer for LanczosFilter No need for a WeakPointer as it's just used only in SceneOpenGL2. REVIEW: 108853
2013-02-08 11:12:51 +00:00
if (!m_lanczosFilter) {
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
m_lanczosFilter = new LanczosFilter(this);
// recreate the lanczos filter when the screen gets resized
Split out screen handling from Workspace into own class Screens Following the approaches of other split out functionality Screens is a singleton class created by Workspace. The class takes over the responsibility for: * screenChanged signal delayed by timer * number of screens * geometry of given screen * active screen * config option for active screen follows mouse The class contains a small abstraction layer and has a concrete subclass wrapping around QDesktopWidget, but the idea is to go more low level and interact with XRandR directly to get more detailed information. All over KWin the usage from QDesktopWidget is ported over to the new Screens class. REVIEW: 109839
2013-04-03 10:19:27 +00:00
connect(screens(), SIGNAL(changed()), SLOT(resetLanczosFilter()));
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
}
Do not use a WeakPointer for LanczosFilter No need for a WeakPointer as it's just used only in SceneOpenGL2. REVIEW: 108853
2013-02-08 11:12:51 +00:00
m_lanczosFilter->performPaint(w, mask, region, data);
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
} else
w->sceneWindow()->performPaint(mask, region, data);
}
Do not use a WeakPointer for LanczosFilter No need for a WeakPointer as it's just used only in SceneOpenGL2. REVIEW: 108853
2013-02-08 11:12:51 +00:00
void SceneOpenGL2::resetLanczosFilter()
{
// TODO: Qt5 - replace by a lambda slot
delete m_lanczosFilter;
m_lanczosFilter = NULL;
}
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
ColorCorrection *SceneOpenGL2::colorCorrection()
{
Only create ColorCorrection if it is enabled in the options According to massif just creating the ColorCorrection costs 2 MiB, so it makes sense to not create it if it is not used. REVIEW: 111604 DIGEST: Smaller memory footprint in KWin 4.11.2 if color correction is disabled
2013-09-04 12:42:45 +00:00
return m_colorCorrection.data();
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
}
Only create ColorCorrection if it is enabled in the options According to massif just creating the ColorCorrection costs 2 MiB, so it makes sense to not create it if it is not used. REVIEW: 111604 DIGEST: Smaller memory footprint in KWin 4.11.2 if color correction is disabled
2013-09-04 12:42:45 +00:00
void SceneOpenGL2::slotColorCorrectedChanged(bool recreateShaders)
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
{
Merge branch 'master' into frameworks-scratch Conflicts: CMakeLists.txt kwin/client.cpp kwin/effects/highlightwindow/highlightwindow.cpp kwin/libkwineffects/kwingltexture.cpp kwin/libkwineffects/kwinxrenderutils.cpp kwin/scene_opengl.cpp kwin/workspace.cpp plasma/desktop/applets/kickoff/CMakeLists.txt plasma/desktop/applets/taskmanager/package/contents/code/tools.js plasma/desktop/applets/taskmanager/package/contents/ui/Task.qml plasma/desktop/applets/taskmanager/package/contents/ui/main.qml plasma/desktop/applets/taskmanager/package/metadata.desktop plasma/desktop/applets/taskmanager/plugin/textlabel.h plasma/desktop/applets/tasks/CMakeLists.txt plasma/desktop/applets/tasks/package/metadata.desktop plasma/desktop/applets/tasks/tasks.cpp plasma/desktop/toolboxes/plasma-toolbox-desktoptoolbox.desktop plasma/generic/applets/activitybar/activitybar.cpp plasma/generic/wallpapers/color/plasma-wallpaper-color.desktop plasma/generic/wallpapers/image/plasma-wallpaper-image.desktop
2013-09-24 09:28:38 +00:00
qDebug() << "Color correction:" << options->isColorCorrected();
Only create ColorCorrection if it is enabled in the options According to massif just creating the ColorCorrection costs 2 MiB, so it makes sense to not create it if it is not used. REVIEW: 111604 DIGEST: Smaller memory footprint in KWin 4.11.2 if color correction is disabled
2013-09-04 12:42:45 +00:00
if (options->isColorCorrected() && m_colorCorrection.isNull()) {
m_colorCorrection.reset(new ColorCorrection(this));
if (!m_colorCorrection->setEnabled(true)) {
m_colorCorrection.reset();
return;
}
connect(m_colorCorrection.data(), SIGNAL(changed()), Compositor::self(), SLOT(addRepaintFull()));
connect(m_colorCorrection.data(), SIGNAL(errorOccured()), options, SLOT(setColorCorrected()), Qt::QueuedConnection);
if (recreateShaders) {
// Reload all shaders
ShaderManager::cleanup();
ShaderManager::instance();
}
} else {
m_colorCorrection.reset();
}
Compositor::self()->addRepaintFull();
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
}
Abort color correction initialization and disable it in case of errors Checks are now performed for GL errors and in case of errors everything is aborted. The error handling mechanism introduced for this purpose somewhat improves the color correction code. Fix gl invalid operation in color correction, when first setting up the lookup texture uniform. REVIEW: 107754
2012-12-16 08:30:50 +00:00
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
//****************************************
// SceneOpenGL1
//****************************************
Introduce a build option KWIN_BUILD_OPENGL_1_COMPOSITING If the build option is enabled KWIN_HAVE_OPENGL_1 is passed as a compile flag when build against OpenGL. This compile flag is meant to replace the KWIN_HAVE_OPENGLES. So far code has been ifdefed for special behavior of OpenGL ES 2.0 and to remove fixed functionality calls which are not available in OpenGL ES 2.0. With this build flag the fixed functionality calls which are only used in the OpenGL1 Compositor can be removed and keeping the KWIN_HAVE_OPENGLES for the real differences between OpenGL 2.x and OpenGL ES 2.0. E.g. a call like glColor4f should be in an glColor4f(1.0, 1.0, 1.0, 1.0); while a call like glPolygonMode should be in an glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); Building for OpenGL ES 2.0 of course implies that KWIN_HAVE_OPENGL_1 is not defined.
2012-10-05 08:45:10 +00:00
#ifdef KWIN_HAVE_OPENGL_1
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
bool SceneOpenGL1::supported(OpenGLBackend *backend)
{
Suppress unused variable warning SVN_SILENT
2012-11-22 13:34:34 +00:00
Q_UNUSED(backend)
GLPlatform can recommend the compositor to use During detecting the OpenGL capabilities also a recommended compositor can be set. This recommendation is honoured by the OpenGL based compositors. That is the SceneOpenGL2 requires a recommendation for at least OpenGL2 and the SceneOpenGL1 requires at least a recommendation for OpenGL1. If the driver recommends XRender compositing the SceneOpenGL performs the existing fallback to XRender. With this recommendation the hacks in the Scene are removed, e.g. it is no longer checked whether the driver is software emulation as that is provided through the recommendation. To overrule the recommendation the environment variable KWIN_COMPOSE is extended by the values O1 and O2 to enforce either OpenGL 1 or OpenGL 2. This overwrites all other checks. As a side-effect this allows now to run KWin on the llvmpipe: LIBGL_ALWAYS_SOFTWARE=1 KWIN_COMPOSE=O2 kwin --replace & But not that I would recommend to use it :-) REVIEW: 106741
2012-10-05 16:00:49 +00:00
const QByteArray forceEnv = qgetenv("KWIN_COMPOSE");
if (!forceEnv.isEmpty()) {
if (qstrcmp(forceEnv, "O1") == 0) {
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "OpenGL 1 compositing enforced by environment variable";
GLPlatform can recommend the compositor to use During detecting the OpenGL capabilities also a recommended compositor can be set. This recommendation is honoured by the OpenGL based compositors. That is the SceneOpenGL2 requires a recommendation for at least OpenGL2 and the SceneOpenGL1 requires at least a recommendation for OpenGL1. If the driver recommends XRender compositing the SceneOpenGL performs the existing fallback to XRender. With this recommendation the hacks in the Scene are removed, e.g. it is no longer checked whether the driver is software emulation as that is provided through the recommendation. To overrule the recommendation the environment variable KWIN_COMPOSE is extended by the values O1 and O2 to enforce either OpenGL 1 or OpenGL 2. This overwrites all other checks. As a side-effect this allows now to run KWin on the llvmpipe: LIBGL_ALWAYS_SOFTWARE=1 KWIN_COMPOSE=O2 kwin --replace & But not that I would recommend to use it :-) REVIEW: 106741
2012-10-05 16:00:49 +00:00
return true;
} else {
// OpenGL 1 disabled by environment variable
return false;
}
}
if (GLPlatform::instance()->recommendedCompositor() < OpenGL1Compositing) {
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "Driver does not recommend OpenGL 1 compositing";
GLPlatform can recommend the compositor to use During detecting the OpenGL capabilities also a recommended compositor can be set. This recommendation is honoured by the OpenGL based compositors. That is the SceneOpenGL2 requires a recommendation for at least OpenGL2 and the SceneOpenGL1 requires at least a recommendation for OpenGL1. If the driver recommends XRender compositing the SceneOpenGL performs the existing fallback to XRender. With this recommendation the hacks in the Scene are removed, e.g. it is no longer checked whether the driver is software emulation as that is provided through the recommendation. To overrule the recommendation the environment variable KWIN_COMPOSE is extended by the values O1 and O2 to enforce either OpenGL 1 or OpenGL 2. This overwrites all other checks. As a side-effect this allows now to run KWin on the llvmpipe: LIBGL_ALWAYS_SOFTWARE=1 KWIN_COMPOSE=O2 kwin --replace & But not that I would recommend to use it :-) REVIEW: 106741
2012-10-05 16:00:49 +00:00
return false;
}
return true;
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
}
SceneOpenGL1::SceneOpenGL1(OpenGLBackend *backend)
: SceneOpenGL(Workspace::self(), backend)
, m_resetModelViewProjectionMatrix(true)
{
Invert logic of init_ok in SceneOpenGL In case that one of the checks in SceneOpenGL failed the ctor of the sub-class continued and set init_ok to true although it should have been set to false. Now init_ok starts with true and if a check fails it is set to false. For 4.11 we should consider using an exception here - variables to check that init code works are just no proper solution. REVIEW: 107420
2012-11-22 14:08:48 +00:00
if (!init_ok) {
// base ctor already failed
return;
}
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
ShaderManager::disable();
setupModelViewProjectionMatrix();
if (checkGLError("Init")) {
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qCritical() << "OpenGL 1 compositing setup failed";
Invert logic of init_ok in SceneOpenGL In case that one of the checks in SceneOpenGL failed the ctor of the sub-class continued and set init_ok to true although it should have been set to false. Now init_ok starts with true and if a check fails it is set to false. For 4.11 we should consider using an exception here - variables to check that init code works are just no proper solution. REVIEW: 107420
2012-11-22 14:08:48 +00:00
init_ok = false;
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
return; // error
}
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "OpenGL 1 compositing successfully initialized";
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
}
SceneOpenGL1::~SceneOpenGL1()
{
}
rebase measuring to nano res + fix vsync padding REVIEW: 109784
2013-03-28 20:53:25 +00:00
qint64 SceneOpenGL1::paint(QRegion damage, ToplevelList windows)
Split SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
{
if (m_resetModelViewProjectionMatrix) {
// reset model view projection matrix if required
setupModelViewProjectionMatrix();
}
return SceneOpenGL::paint(damage, windows);
}
void SceneOpenGL1::paintGenericScreen(int mask, ScreenPaintData data)
{
pushMatrix(transformation(mask, data));
Scene::paintGenericScreen(mask, data);
popMatrix();
}
void SceneOpenGL1::doPaintBackground(const QVector< float >& vertices)
{
GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
vbo->reset();
vbo->setUseColor(true);
vbo->setData(vertices.count() / 2, 2, vertices.data(), NULL);
vbo->render(GL_TRIANGLES);
}
void SceneOpenGL1::setupModelViewProjectionMatrix()
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
float fovy = 60.0f;
float aspect = 1.0f;
float zNear = 0.1f;
float zFar = 100.0f;
float ymax = zNear * tan(fovy * M_PI / 360.0f);
float ymin = -ymax;
float xmin = ymin * aspect;
float xmax = ymax * aspect;
// swap top and bottom to have OpenGL coordinate system match X system
glFrustum(xmin, xmax, ymin, ymax, zNear, zFar);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
float scaleFactor = 1.1 * tan(fovy * M_PI / 360.0f) / ymax;
glTranslatef(xmin * scaleFactor, ymax * scaleFactor, -1.1);
glScalef((xmax - xmin)*scaleFactor / displayWidth(), -(ymax - ymin)*scaleFactor / displayHeight(), 0.001);
m_resetModelViewProjectionMatrix = false;
}
void SceneOpenGL1::screenGeometryChanged(const QSize &size)
{
SceneOpenGL::screenGeometryChanged(size);
m_resetModelViewProjectionMatrix = true;
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 SceneOpenGL into a concrete SceneOpenGL1 and SceneOpenGL2 SceneOpenGL turns into an abstract class with two concrete subclasses: * SceneOpenGL1 * SceneOpenGL2 It provides a factory method which first creates either the GLX or EGL backend which is passed to a static supported() method in the concrete sub classes. These method can test whether the backend is sufficient to be used for the OpenGL version in question. E.g. the OpenGL 2 scene checks whether the context is direct. The actual rendering is moved into the subclasses with specific OpenGL 1 and OpenGL 2 code. This should make the code more readable and requires less checks whether a Shader is bound. This is now known through the Scene: the OpenGL1 scene will never have a shader bound, the OpenGL2 scene will always have a shader bound. To make this more reliable the ShaderManager is extended by a disable method used by SceneOpenGL1 to ensure that the ShaderManager will never be used. This also obsoletes the need to read the KWin configuration whether legacy GL is enabled. The check is moved into the supported method of the OpenGL2 scene. REVIEW: 106357
2012-09-06 15:13:22 +00:00
SceneOpenGL::Window *SceneOpenGL1::createWindow(Toplevel *t)
{
return new SceneOpenGL1Window(t);
}
#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
//****************************************
// SceneOpenGL::Texture
//****************************************
SceneOpenGL::Texture::Texture(OpenGLBackend *backend)
: GLTexture(*backend->createBackendTexture(this))
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +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::Texture::Texture(OpenGLBackend *backend, const QPixmap &pix, GLenum target)
: GLTexture(*backend->createBackendTexture(this))
KWin supports graphicssystem Raster With raster a QPixmap is no longer a XPixmap which fails all code which assumes that an QPixmap is an XPixmap. Depending on were in the codebase we either convert such pixmaps to images (OpenGL) or create a XPixmap and use QPixmap::fromX11Pixmap to get a "real" pixmap. It is possible that there are more code pathes were we would need a XPixmap. Currently tested is basic functionality of no-compositing, XRender compositing, OpenGl/GLX and OpenGL ES/EGL compositing. For OpenGL compositing raster might result in performance improvements, for XRender it is possible that there are regressions when using raster. By default KWin uses whatever is the default of the system, so we just no longer enforce native. Of course it is a bad idea to use graphicssystem OpenGL. As that is broken anyways in Qt, we do not check for it. Many thanks to Philipp Knechtges for bringing up the issue, convincing me that we need it and providing most of the patch. REVIEW: 101132 CCMAIL: Philipp.Knechtges@rwth-aachen.de
2011-05-12 16:52:38 +00:00
{
load(pix, target);
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
SceneOpenGL::Texture::~Texture()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +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
SceneOpenGL::Texture& SceneOpenGL::Texture::operator = (const SceneOpenGL::Texture& tex)
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
d_ptr = tex.d_ptr;
return *this;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
void SceneOpenGL::Texture::discard()
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
d_ptr = d_func()->backend()->createBackendTexture(this);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
bool SceneOpenGL::Texture::load(const Pixmap& pix, const QSize& size,
int depth)
{
Fix GL error when do texture from pixmap This problem happens on Freescale imx51 ARM platform CCMAIL: patches@linaro.org
2011-03-10 09:50:42 +00:00
if (pix == None)
return false;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
return load(pix, size, depth,
QRegion(0, 0, size.width(), size.height()));
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
bool SceneOpenGL::Texture::load(const QImage& image, GLenum target)
{
if (image.isNull())
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
return false;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
return load(QPixmap::fromImage(image), target);
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
bool SceneOpenGL::Texture::load(const QPixmap& pixmap, GLenum target)
{
if (pixmap.isNull())
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
return false;
KWin supports graphicssystem Raster With raster a QPixmap is no longer a XPixmap which fails all code which assumes that an QPixmap is an XPixmap. Depending on were in the codebase we either convert such pixmaps to images (OpenGL) or create a XPixmap and use QPixmap::fromX11Pixmap to get a "real" pixmap. It is possible that there are more code pathes were we would need a XPixmap. Currently tested is basic functionality of no-compositing, XRender compositing, OpenGl/GLX and OpenGL ES/EGL compositing. For OpenGL compositing raster might result in performance improvements, for XRender it is possible that there are regressions when using raster. By default KWin uses whatever is the default of the system, so we just no longer enforce native. Of course it is a bad idea to use graphicssystem OpenGL. As that is broken anyways in Qt, we do not check for it. Many thanks to Philipp Knechtges for bringing up the issue, convincing me that we need it and providing most of the patch. REVIEW: 101132 CCMAIL: Philipp.Knechtges@rwth-aachen.de
2011-05-12 16:52:38 +00:00
Drop support for native graphics system Qt 5 only supports raster which means our pixmaps are always non native, so we don't need the Extension information any more and can drop all special code handling for mapping a native QPixmap to an X11 pixmap.
2013-07-22 13:51:56 +00:00
return GLTexture::load(pixmap.toImage(), target);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +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 SceneOpenGL::Texture::findTarget()
{
Q_D(Texture);
d->findTarget();
}
bool SceneOpenGL::Texture::load(const Pixmap& pix, const QSize& size,
int depth, QRegion region)
{
Q_UNUSED(region)
// decrease the reference counter for the old texture
d_ptr = d_func()->backend()->createBackendTexture(this); //new TexturePrivate();
Q_D(Texture);
return d->loadTexture(pix, size, depth);
}
Egl Backend using a Wayland surface for rendering This backend is able to composite on a Wayland surface instead of an X11 overlay window. It can be considered as a prototype for a Wayland session compositor. For texture from X11 pixmap the backend uses XShm. This is far from optimal, but the KHR_image_pixmap extension is not available in Mesa's Wayland backend. It's a temporary solution till we have XWayland and texture from Wayland buffer. To use this backend one needs to specify the environment variable KWIN_OPENGL_INTERFACE with "egl_wayland". In future KWin should probably use this backend if the Wayland display env variable is defined. To use this setup: 1. Have a normal X-Server running on e.g. VT7 2. Start Weston on VT1 3. Start a terminal on Weston 4. start KWin with: DISPLAY=:0 KWIN_OPENGL_INTERFACE=egl_wayland kwin --replace & This should map a Wayland surface to Weston showing the content of the X setup. At the moment it's not yet possible to interact with the surface as input events are not yet recieved in the backend. There are still a lot of limitations as documented in the code.
2013-05-15 11:47:27 +00:00
bool SceneOpenGL::Texture::update(const QRegion &damage)
{
Q_D(Texture);
return d->update(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
//****************************************
// SceneOpenGL::Texture
//****************************************
SceneOpenGL::TexturePrivate::TexturePrivate()
{
}
SceneOpenGL::TexturePrivate::~TexturePrivate()
{
}
Egl Backend using a Wayland surface for rendering This backend is able to composite on a Wayland surface instead of an X11 overlay window. It can be considered as a prototype for a Wayland session compositor. For texture from X11 pixmap the backend uses XShm. This is far from optimal, but the KHR_image_pixmap extension is not available in Mesa's Wayland backend. It's a temporary solution till we have XWayland and texture from Wayland buffer. To use this backend one needs to specify the environment variable KWIN_OPENGL_INTERFACE with "egl_wayland". In future KWin should probably use this backend if the Wayland display env variable is defined. To use this setup: 1. Have a normal X-Server running on e.g. VT7 2. Start Weston on VT1 3. Start a terminal on Weston 4. start KWin with: DISPLAY=:0 KWIN_OPENGL_INTERFACE=egl_wayland kwin --replace & This should map a Wayland surface to Weston showing the content of the X setup. At the moment it's not yet possible to interact with the surface as input events are not yet recieved in the backend. There are still a lot of limitations as documented in the code.
2013-05-15 11:47:27 +00:00
bool SceneOpenGL::TexturePrivate::update(const QRegion &damage)
{
Q_UNUSED(damage)
return true;
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
//****************************************
// SceneOpenGL::Window
//****************************************
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
SceneOpenGL::Window::Window(Toplevel* c)
: Scene::Window(c)
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
, m_scene(NULL)
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
SceneOpenGL::Window::~Window()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
New class to encapsulate a Window's Pixmap The behavior for creating a pixmap for a window is moved from Toplevel into a dedicated class WindowPixmap. Scene::Window holds a reference to this class and creates a new WindowPixmap whenever the pixmap needs to be discarded. In addition it also keeps the old WindowPixmap around for the case that creating the new pixmap fails. The compositor can in that case use the previous pixmap which reduces possible flickering. Also this referencing can be used to improve transition effects like the maximize windows effect which would benefit from starting with the old pixmap. For XRender and OpenGL a dedicated sub-class of the WindowPixmap is created which provides the additional mapping to an XRender picture and OpenGL texture respectively. BUG: 319563 FIXED-IN: 4.11 REVIEW: 110577
2013-05-10 10:07:56 +00:00
static SceneOpenGL::Texture *s_frameTexture = NULL;
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
// Bind the window pixmap to an OpenGL texture.
bool SceneOpenGL::Window::bindTexture()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
New class to encapsulate a Window's Pixmap The behavior for creating a pixmap for a window is moved from Toplevel into a dedicated class WindowPixmap. Scene::Window holds a reference to this class and creates a new WindowPixmap whenever the pixmap needs to be discarded. In addition it also keeps the old WindowPixmap around for the case that creating the new pixmap fails. The compositor can in that case use the previous pixmap which reduces possible flickering. Also this referencing can be used to improve transition effects like the maximize windows effect which would benefit from starting with the old pixmap. For XRender and OpenGL a dedicated sub-class of the WindowPixmap is created which provides the additional mapping to an XRender picture and OpenGL texture respectively. BUG: 319563 FIXED-IN: 4.11 REVIEW: 110577
2013-05-10 10:07:56 +00:00
s_frameTexture = NULL;
OpenGLWindowPixmap *pixmap = windowPixmap<OpenGLWindowPixmap>();
if (!pixmap) {
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
}
New class to encapsulate a Window's Pixmap The behavior for creating a pixmap for a window is moved from Toplevel into a dedicated class WindowPixmap. Scene::Window holds a reference to this class and creates a new WindowPixmap whenever the pixmap needs to be discarded. In addition it also keeps the old WindowPixmap around for the case that creating the new pixmap fails. The compositor can in that case use the previous pixmap which reduces possible flickering. Also this referencing can be used to improve transition effects like the maximize windows effect which would benefit from starting with the old pixmap. For XRender and OpenGL a dedicated sub-class of the WindowPixmap is created which provides the additional mapping to an XRender picture and OpenGL texture respectively. BUG: 319563 FIXED-IN: 4.11 REVIEW: 110577
2013-05-10 10:07:56 +00:00
s_frameTexture = pixmap->texture();
if (pixmap->isDiscarded()) {
return !pixmap->texture()->isNull();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
New class to encapsulate a Window's Pixmap The behavior for creating a pixmap for a window is moved from Toplevel into a dedicated class WindowPixmap. Scene::Window holds a reference to this class and creates a new WindowPixmap whenever the pixmap needs to be discarded. In addition it also keeps the old WindowPixmap around for the case that creating the new pixmap fails. The compositor can in that case use the previous pixmap which reduces possible flickering. Also this referencing can be used to improve transition effects like the maximize windows effect which would benefit from starting with the old pixmap. For XRender and OpenGL a dedicated sub-class of the WindowPixmap is created which provides the additional mapping to an XRender picture and OpenGL texture respectively. BUG: 319563 FIXED-IN: 4.11 REVIEW: 110577
2013-05-10 10:07:56 +00:00
return pixmap->bind();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Make sure to unbind the texture in tfp_mode when the underlying pixmap is discarded. Windows that have previously been mapped and unmapped now update properly when mapped again. svn path=/trunk/KDE/kdebase/workspace/; revision=683977
2007-07-05 19:59:55 +00:00
kwin: Refactor the window transformation code Move the code that computes the transformation matrix into its own method, and rewrite it to improve readability.
2011-02-15 17:10:54 +00:00
QMatrix4x4 SceneOpenGL::Window::transformation(int mask, const WindowPaintData &data) const
{
QMatrix4x4 matrix;
matrix.translate(x(), y());
if (!(mask & PAINT_WINDOW_TRANSFORMED))
return matrix;
Replace translation by QVector3D in Screen/Window PaintData
2012-05-28 12:45:46 +00:00
matrix.translate(data.translation());
Use QGraphicsScale for scale information in ScreenPaintData
2012-05-28 10:00:31 +00:00
data.scale().applyTo(&matrix);
kwin: Refactor the window transformation code Move the code that computes the transformation matrix into its own method, and rewrite it to improve readability.
2011-02-15 17:10:54 +00:00
Split out common part of ScreenPaintData and WindowPaintData New common d-pointered class PaintData is added which cannot be instantiated.
2012-06-02 19:54:18 +00:00
if (data.rotationAngle() == 0.0)
kwin: Refactor the window transformation code Move the code that computes the transformation matrix into its own method, and rewrite it to improve readability.
2011-02-15 17:10:54 +00:00
return matrix;
// Apply the rotation
Replace custom RotationData with QGraphicsRotation
2012-05-27 17:28:02 +00:00
// cannot use data.rotation.applyTo(&matrix) as QGraphicsRotation uses projectedRotate to map back to 2D
Split out common part of ScreenPaintData and WindowPaintData New common d-pointered class PaintData is added which cannot be instantiated.
2012-06-02 19:54:18 +00:00
matrix.translate(data.rotationOrigin());
const QVector3D axis = data.rotationAxis();
matrix.rotate(data.rotationAngle(), axis.x(), axis.y(), axis.z());
matrix.translate(-data.rotationOrigin());
kwin: Refactor the window transformation code Move the code that computes the transformation matrix into its own method, and rewrite it to improve readability.
2011-02-15 17:10:54 +00:00
return matrix;
}
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
bool SceneOpenGL::Window::beginRenderWindow(int mask, const QRegion &region, WindowPaintData &data)
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
if (region.isEmpty())
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
return false;
kwin: Fix the clip intersection code The code that intersected the clip region with the window region appears to have been accidentally lost in 5ce3c6b8.
2011-02-15 21:34:23 +00:00
kwin: Make hardwareClipping a member
2013-03-17 10:50:47 +00:00
m_hardwareClipping = region != infiniteRegion() && (mask & PAINT_WINDOW_TRANSFORMED) && !(mask & PAINT_SCREEN_TRANSFORMED);
if (region != infiniteRegion() && !m_hardwareClipping) {
Remove PaintClipper from OpenGL Scene rendering Construct window quads which will end on the screen instead of rendering the windows several times and using scissoring to restrict to the area which will end on screen. REVIEW: 101765
2011-06-26 10:01:13 +00:00
WindowQuadList quads;
kwin: Call reserve() on the quad list before clipping Assume that we will end up with the same number of quads.
2013-06-11 19:16:09 +00:00
quads.reserve(data.quads.count());
Remove PaintClipper from OpenGL Scene rendering Construct window quads which will end on the screen instead of rendering the windows several times and using scissoring to restrict to the area which will end on screen. REVIEW: 101765
2011-06-26 10:01:13 +00:00
const QRegion filterRegion = region.translated(-x(), -y());
Remove clipping against the bounding rect of paint region
2011-06-26 11:16:14 +00:00
// split all quads in bounding rect with the actual rects in the region
Remove PaintClipper from OpenGL Scene rendering Construct window quads which will end on the screen instead of rendering the windows several times and using scissoring to restrict to the area which will end on screen. REVIEW: 101765
2011-06-26 10:01:13 +00:00
foreach (const WindowQuad &quad, data.quads) {
Remove clipping against the bounding rect of paint region
2011-06-26 11:16:14 +00:00
foreach (const QRect &r, filterRegion.rects()) {
const QRectF rf(r);
const QRectF quadRect(QPointF(quad.left(), quad.top()), QPointF(quad.right(), quad.bottom()));
Calculate the intersection only once The intersection of rects are calculated twice without need. The function QRectF::intersected() calculate and returns the intersection. If there are no interesection, the returned QRectF is empty. If the intersected QRectF is equal to QRectF argument, it contains the QRectF argument. Reviewed in: https://git.reviewboard.kde.org/r/114036/
2013-11-28 12:19:48 +00:00
const QRectF &intersected = rf.intersected(quadRect);
if (intersected.isValid()) {
if (quadRect == intersected) {
// case 1: completely contains, include and do not check other rects
quads << quad;
break;
}
// case 2: intersection
Remove clipping against the bounding rect of paint region
2011-06-26 11:16:14 +00:00
quads << quad.makeSubQuad(intersected.left(), intersected.top(), intersected.right(), intersected.bottom());
Remove PaintClipper from OpenGL Scene rendering Construct window quads which will end on the screen instead of rendering the windows several times and using scissoring to restrict to the area which will end on screen. REVIEW: 101765
2011-06-26 10:01:13 +00:00
}
}
}
Remove clipping against the bounding rect of paint region
2011-06-26 11:16:14 +00:00
data.quads = quads;
Remove PaintClipper from OpenGL Scene rendering Construct window quads which will end on the screen instead of rendering the windows several times and using scissoring to restrict to the area which will end on screen. REVIEW: 101765
2011-06-26 10:01:13 +00:00
}
kwin: Check for an empty quad list in beginRenderWindow() BUG: 320845
2013-06-07 21:46:06 +00:00
if (data.quads.isEmpty())
return false;
New class to encapsulate a Window's Pixmap The behavior for creating a pixmap for a window is moved from Toplevel into a dedicated class WindowPixmap. Scene::Window holds a reference to this class and creates a new WindowPixmap whenever the pixmap needs to be discarded. In addition it also keeps the old WindowPixmap around for the case that creating the new pixmap fails. The compositor can in that case use the previous pixmap which reduces possible flickering. Also this referencing can be used to improve transition effects like the maximize windows effect which would benefit from starting with the old pixmap. For XRender and OpenGL a dedicated sub-class of the WindowPixmap is created which provides the additional mapping to an XRender picture and OpenGL texture respectively. BUG: 319563 FIXED-IN: 4.11 REVIEW: 110577
2013-05-10 10:07:56 +00:00
if (!bindTexture() || !s_frameTexture) {
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
return false;
kwin: adding proper clipping for transformed windows This patch kind of reintroduces the old PaintClipper functionality. REVIEW: 104397
2012-02-12 15:42:09 +00:00
}
kwin: Make hardwareClipping a member
2013-03-17 10:50:47 +00:00
if (m_hardwareClipping) {
kwin: adding proper clipping for transformed windows This patch kind of reintroduces the old PaintClipper functionality. REVIEW: 104397
2012-02-12 15:42:09 +00:00
glEnable(GL_SCISSOR_TEST);
}
kwin: Simplify the code for updating the texture filter
2011-02-15 16:47:31 +00:00
// Update the texture filter
Refactoring of KWin::Options: getter methods instead of public variables
2012-02-20 09:25:13 +00:00
if (options->glSmoothScale() != 0 &&
kwin: Simplify the code for updating the texture filter
2011-02-15 16:47:31 +00:00
(mask & (PAINT_WINDOW_TRANSFORMED | PAINT_SCREEN_TRANSFORMED)))
filter = ImageFilterGood;
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
else
kwin: Simplify the code for updating the texture filter
2011-02-15 16:47:31 +00:00
filter = ImageFilterFast;
New class to encapsulate a Window's Pixmap The behavior for creating a pixmap for a window is moved from Toplevel into a dedicated class WindowPixmap. Scene::Window holds a reference to this class and creates a new WindowPixmap whenever the pixmap needs to be discarded. In addition it also keeps the old WindowPixmap around for the case that creating the new pixmap fails. The compositor can in that case use the previous pixmap which reduces possible flickering. Also this referencing can be used to improve transition effects like the maximize windows effect which would benefit from starting with the old pixmap. For XRender and OpenGL a dedicated sub-class of the WindowPixmap is created which provides the additional mapping to an XRender picture and OpenGL texture respectively. BUG: 319563 FIXED-IN: 4.11 REVIEW: 110577
2013-05-10 10:07:56 +00:00
s_frameTexture->setFilter(filter == ImageFilterGood ? GL_LINEAR : GL_NEAREST);
kwin: Simplify the code for updating the texture filter
2011-02-15 16:47:31 +00:00
kwin: Declare the attribute layout once in SceneOpenGL::Window The same layout is used for all draw calls in SceneOpenGL::Window::performPaint().
2012-10-12 11:20:23 +00:00
const GLVertexAttrib attribs[] = {
{ VA_Position, 2, GL_FLOAT, offsetof(GLVertex2D, position) },
{ VA_TexCoord, 2, GL_FLOAT, offsetof(GLVertex2D, texcoord) },
};
And use shared VBO for windows
2010-12-11 15:11:19 +00:00
GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
vbo->reset();
kwin: Declare the attribute layout once in SceneOpenGL::Window The same layout is used for all draw calls in SceneOpenGL::Window::performPaint().
2012-10-12 11:20:23 +00:00
vbo->setAttribLayout(attribs, 2, sizeof(GLVertex2D));
OpenGL part of ARGB decorations. See revision 957680 for more information. svn path=/trunk/KDE/kdebase/workspace/; revision=957681
2009-04-22 17:30:49 +00:00
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
return true;
}
Switch the order, so the decoration is drawn before the client window. svn path=/trunk/KDE/kdebase/workspace/; revision=1054380
2009-11-25 23:08:19 +00:00
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
void SceneOpenGL::Window::endRenderWindow()
{
kwin: Make hardwareClipping a member
2013-03-17 10:50:47 +00:00
if (m_hardwareClipping) {
kwin: adding proper clipping for transformed windows This patch kind of reintroduces the old PaintClipper functionality. REVIEW: 104397
2012-02-12 15:42:09 +00:00
glDisable(GL_SCISSOR_TEST);
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
OpenGL part of ARGB decorations. See revision 957680 for more information. svn path=/trunk/KDE/kdebase/workspace/; revision=957681
2009-04-22 17:30:49 +00:00
kwin: Add new convenience methods in SceneOpenGL Add a paintRedirector() and a getDecorationTextures() method. These will be used in an upcoming commit.
2013-03-17 11:16:08 +00:00
OpenGLPaintRedirector *SceneOpenGL::Window::paintRedirector() const
{
if (toplevel->isClient()) {
Client *client = static_cast<Client *>(toplevel);
if (client->noBorder())
return 0;
return static_cast<OpenGLPaintRedirector *>(client->decorationPaintRedirector());
}
if (toplevel->isDeleted()) {
Deleted *deleted = static_cast<Deleted *>(toplevel);
if (deleted->noBorder())
return 0;
return static_cast<OpenGLPaintRedirector *>(deleted->decorationPaintRedirector());
}
return 0;
}
bool SceneOpenGL::Window::getDecorationTextures(GLTexture **textures) const
{
OpenGLPaintRedirector *redirector = paintRedirector();
if (!redirector)
return false;
redirector->ensurePixmapsPainted();
textures[0] = redirector->leftRightTexture();
textures[1] = redirector->topBottomTexture();
redirector->markAsRepainted();
return true;
}
kwin: Make hardwareClipping a member
2013-03-17 10:50:47 +00:00
void SceneOpenGL::Window::paintDecorations(const WindowPaintData &data, const QRegion &region)
Merge the code to render Client's and Deleted's decoration in SceneOpenGL The code was basically copy'n'pasted to handle both Client and Deleted requiring to cast the Toplevel to both Client and Deleted to test whether it is one of those. This is now changed from runtime to compile time polymorphism. A templated method is used to start the rendering process for the decos. This on the one hand simplifies the code and on the other does not require any dynamic casts any more as we use the available check on Toplevel whether it is a Client or Deleted.
2012-09-06 10:55:15 +00:00
{
kwin: Add new convenience methods in SceneOpenGL Add a paintRedirector() and a getDecorationTextures() method. These will be used in an upcoming commit.
2013-03-17 11:16:08 +00:00
GLTexture *textures[2];
if (!getDecorationTextures(textures))
Merge the code to render Client's and Deleted's decoration in SceneOpenGL The code was basically copy'n'pasted to handle both Client and Deleted requiring to cast the Toplevel to both Client and Deleted to test whether it is one of those. This is now changed from runtime to compile time polymorphism. A templated method is used to start the rendering process for the decos. This on the one hand simplifies the code and on the other does not require any dynamic casts any more as we use the available check on Toplevel whether it is a Client or Deleted.
2012-09-06 10:55:15 +00:00
return;
kwin: Use texture atlases for the decorations Use two textures per window instead of four, storing the left and right borders in the first texture, and the top and bottom borders in the second. This makes it possible to render the whole decoration with only two calls to glDrawArrays(). It also reduces the number of texture allocations while resizing a window.
2013-03-15 17:01:44 +00:00
WindowQuadList quads[2]; // left-right, top-bottom
Merge the code to render Client's and Deleted's decoration in SceneOpenGL The code was basically copy'n'pasted to handle both Client and Deleted requiring to cast the Toplevel to both Client and Deleted to test whether it is one of those. This is now changed from runtime to compile time polymorphism. A templated method is used to start the rendering process for the decos. This on the one hand simplifies the code and on the other does not require any dynamic casts any more as we use the available check on Toplevel whether it is a Client or Deleted.
2012-09-06 10:55:15 +00:00
kwin: Use texture atlases for the decorations Use two textures per window instead of four, storing the left and right borders in the first texture, and the top and bottom borders in the second. This makes it possible to render the whole decoration with only two calls to glDrawArrays(). It also reduces the number of texture allocations while resizing a window.
2013-03-15 17:01:44 +00:00
// Split the quads into two lists
kwin: Optimize decoration quad selection Loop directly over the window quad list and check the type instead of using select(WindowQuadDecoration) when separating the decoration quads. This avoids the step of creating an intermediate list, and then looping over that list to separate out the quads that belong to the four sides.
2013-03-15 14:16:12 +00:00
foreach (const WindowQuad &quad, data.quads) {
kwin: Split WindowQuadDecoration into two types Split WindowQuadDecoration into WindowQuadDecorationLeftRight and WindowQuadDecorationTopBottom. This simplifies the code in SceneOpenGL::Window::paintDecoration().
2013-03-16 23:40:15 +00:00
switch (quad.type()) {
case WindowQuadDecorationLeftRight:
quads[0].append(quad);
continue;
case WindowQuadDecorationTopBottom:
quads[1].append(quad);
kwin: Optimize decoration quad selection Loop directly over the window quad list and check the type instead of using select(WindowQuadDecoration) when separating the decoration quads. This avoids the step of creating an intermediate list, and then looping over that list to separate out the quads that belong to the four sides.
2013-03-15 14:16:12 +00:00
continue;
kwin: Split WindowQuadDecoration into two types Split WindowQuadDecoration into WindowQuadDecorationLeftRight and WindowQuadDecorationTopBottom. This simplifies the code in SceneOpenGL::Window::paintDecoration().
2013-03-16 23:40:15 +00:00
default:
continue;
Merge the code to render Client's and Deleted's decoration in SceneOpenGL The code was basically copy'n'pasted to handle both Client and Deleted requiring to cast the Toplevel to both Client and Deleted to test whether it is one of those. This is now changed from runtime to compile time polymorphism. A templated method is used to start the rendering process for the decos. This on the one hand simplifies the code and on the other does not require any dynamic casts any more as we use the available check on Toplevel whether it is a Client or Deleted.
2012-09-06 10:55:15 +00:00
}
}
kwin: Use texture atlases for the decorations Use two textures per window instead of four, storing the left and right borders in the first texture, and the top and bottom borders in the second. This makes it possible to render the whole decoration with only two calls to glDrawArrays(). It also reduces the number of texture allocations while resizing a window.
2013-03-15 17:01:44 +00:00
TextureType type[] = { DecorationLeftRight, DecorationTopBottom };
for (int i = 0; i < 2; i++)
kwin: Make hardwareClipping a member
2013-03-17 10:50:47 +00:00
paintDecoration(textures[i], type[i], region, data, quads[i]);
Merge the code to render Client's and Deleted's decoration in SceneOpenGL The code was basically copy'n'pasted to handle both Client and Deleted requiring to cast the Toplevel to both Client and Deleted to test whether it is one of those. This is now changed from runtime to compile time polymorphism. A templated method is used to start the rendering process for the decos. This on the one hand simplifies the code and on the other does not require any dynamic casts any more as we use the available check on Toplevel whether it is a Client or Deleted.
2012-09-06 10:55:15 +00:00
}
kwin: Set the texcoords in the decoration quads This way we don't have to compute them in makeDecorationArrays().
2013-03-16 11:21:59 +00:00
void SceneOpenGL::Window::paintDecoration(GLTexture *texture, TextureType type,
const QRegion &region, const WindowPaintData &data,
kwin: Make hardwareClipping a member
2013-03-17 10:50:47 +00:00
const WindowQuadList &quads)
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
kwin: Refactor the decoration code a bit
2013-03-15 14:11:40 +00:00
if (!texture || quads.isEmpty())
kwin: update the decoration texture although we dont paint the decoration We have to update the texture because the next time client->decorationPixmapRequiresRepaint() might return false.
2011-07-06 15:13:41 +00:00
return;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (filter == ImageFilterGood)
kwin: Refactor the decoration code a bit
2013-03-15 14:11:40 +00:00
texture->setFilter(GL_LINEAR);
Separate rendering for decoration and window contents, they can have different opacity (opacity only for decoration option). svn path=/trunk/KDE/kdebase/workspace/; revision=689855
2007-07-19 10:07:49 +00:00
else
kwin: Refactor the decoration code a bit
2013-03-15 14:11:40 +00:00
texture->setFilter(GL_NEAREST);
texture->setWrapMode(GL_CLAMP_TO_EDGE);
texture->bind();
OpenGL part of ARGB decorations. See revision 957680 for more information. svn path=/trunk/KDE/kdebase/workspace/; revision=957681
2009-04-22 17:30:49 +00:00
kwin: Set the texcoords in the decoration quads This way we don't have to compute them in makeDecorationArrays().
2013-03-16 11:21:59 +00:00
prepareStates(type, data.opacity() * data.decorationOpacity(), data.brightness(), data.saturation(), data.screen());
kwin: Make hardwareClipping a member
2013-03-17 10:50:47 +00:00
renderQuads(0, region, quads, texture, false);
kwin: Set the texcoords in the decoration quads This way we don't have to compute them in makeDecorationArrays().
2013-03-16 11:21:59 +00:00
restoreStates(type, data.opacity() * data.decorationOpacity(), data.brightness(), data.saturation());
kwin: Refactor the decoration code a bit
2013-03-15 14:11:40 +00:00
texture->unbind();
Scene OpenGL compiles with ES It's mostly just ifdef away everything that cannot work. Needs to be split into a scene_xgl and scene_egl.
2010-11-20 12:27:47 +00:00
#ifndef KWIN_HAVE_OPENGLES
kwin: Rename SceneOpenGL::debug to m_debug and add an accessor
2013-03-17 11:58:36 +00:00
if (m_scene && m_scene->debug()) {
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
kwin: Make hardwareClipping a member
2013-03-17 10:50:47 +00:00
GLVertexBuffer::streamingBuffer()->render(region, GL_TRIANGLES, m_hardwareClipping);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
OpenGL part of ARGB decorations. See revision 957680 for more information. svn path=/trunk/KDE/kdebase/workspace/; revision=957681
2009-04-22 17:30:49 +00:00
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
#endif
}
Separate rendering for decoration and window contents, they can have different opacity (opacity only for decoration option). svn path=/trunk/KDE/kdebase/workspace/; revision=689855
2007-07-19 10:07:49 +00:00
kwin: Make hardwareClipping a member
2013-03-17 10:50:47 +00:00
void SceneOpenGL::Window::paintShadow(const QRegion &region, const WindowPaintData &data)
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
{
kwin: Optimize shadow quad selection Loop over the window quad list once instead of eight times when selecting the shadow quads.
2013-05-29 15:49:53 +00:00
WindowQuadList quads;
foreach (const WindowQuad &quad, data.quads) {
switch (quad.type()) {
case WindowQuadShadowTopLeft:
case WindowQuadShadowTop:
case WindowQuadShadowTopRight:
case WindowQuadShadowLeft:
case WindowQuadShadowRight:
case WindowQuadShadowBottomLeft:
case WindowQuadShadowBottom:
case WindowQuadShadowBottomRight:
quads.append(quad);
break;
default:
break;
}
Don't render shadows if there are no quads
2011-06-26 10:00:08 +00:00
}
kwin: Optimize shadow quad selection Loop over the window quad list once instead of eight times when selecting the shadow quads.
2013-05-29 15:49:53 +00:00
if (quads.isEmpty())
return;
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
GLTexture *texture = static_cast<SceneOpenGLShadow*>(m_shadow)->shadowTexture();
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
if (!texture) {
return;
}
if (filter == ImageFilterGood)
texture->setFilter(GL_LINEAR);
else
texture->setFilter(GL_NEAREST);
texture->setWrapMode(GL_CLAMP_TO_EDGE);
texture->bind();
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
prepareStates(Shadow, data.opacity(), data.brightness(), data.saturation(), data.screen());
kwin: Make hardwareClipping a member
2013-03-17 10:50:47 +00:00
renderQuads(0, region, quads, texture, true);
Revert "Merge branch 'color2'" This merge is incomplete and it does not include the review number of the associated review request. It should have been pushed as a single commit, because the merged commits were not intended to be published in their form. This reverts commit dcba90263069a221a5489b1915c5cf1ca39d090c, reversing changes made to 50ae07525c7fde07794e7548c3d6e5a69cb1a89d. Conflicts: kwin/scene_opengl.cpp kwin/scene_opengl.h
2012-11-13 20:19:01 +00:00
restoreStates(Shadow, data.opacity(), data.brightness(), data.saturation());
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
texture->unbind();
Add debug rendering for shadow code
2011-03-30 18:32:27 +00:00
#ifndef KWIN_HAVE_OPENGLES
kwin: Rename SceneOpenGL::debug to m_debug and add an accessor
2013-03-17 11:58:36 +00:00
if (m_scene && m_scene->debug()) {
Add debug rendering for shadow code
2011-03-30 18:32:27 +00:00
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
kwin: Make hardwareClipping a member
2013-03-17 10:50:47 +00:00
renderQuads(0, region, quads, texture, true);
Add debug rendering for shadow code
2011-03-30 18:32:27 +00:00
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
#endif
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
}
kwin: adding proper clipping for transformed windows This patch kind of reintroduces the old PaintClipper functionality. REVIEW: 104397
2012-02-12 15:42:09 +00:00
void SceneOpenGL::Window::renderQuads(int, const QRegion& region, const WindowQuadList& quads,
kwin: Make hardwareClipping a member
2013-03-17 10:50:47 +00:00
GLTexture *tex, bool normalized)
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
if (quads.isEmpty())
Separate rendering for decoration and window contents, they can have different opacity (opacity only for decoration option). svn path=/trunk/KDE/kdebase/workspace/; revision=689855
2007-07-19 10:07:49 +00:00
return;
kwin: Use the new map() interface in renderQuads() Write the vertex data directly into the buffer object, instead of allocating two temporary arrays, coyping the data into them, and then copying the data from the arrays into the buffer object. This also makes renderQuads() handle coordinates for rectangular textures correctly.
2012-09-18 20:24:58 +00:00
const QMatrix4x4 matrix = tex->matrix(normalized ? NormalizedCoordinates : UnnormalizedCoordinates);
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
// Render geometry
kwin: Use the new API for rendering quads
2013-03-21 22:52:03 +00:00
GLenum primitiveType;
int primcount;
if (GLVertexBuffer::supportsIndexedQuads()) {
primitiveType = GL_QUADS_KWIN;
primcount = quads.count() * 4;
} else {
primitiveType = GL_TRIANGLES;
primcount = quads.count() * 6;
}
kwin: Use the new map() interface in renderQuads() Write the vertex data directly into the buffer object, instead of allocating two temporary arrays, coyping the data into them, and then copying the data from the arrays into the buffer object. This also makes renderQuads() handle coordinates for rectangular textures correctly.
2012-09-18 20:24:58 +00:00
GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
kwin: Use the new API for rendering quads
2013-03-21 22:52:03 +00:00
vbo->setVertexCount(primcount);
kwin: Use the new map() interface in renderQuads() Write the vertex data directly into the buffer object, instead of allocating two temporary arrays, coyping the data into them, and then copying the data from the arrays into the buffer object. This also makes renderQuads() handle coordinates for rectangular textures correctly.
2012-09-18 20:24:58 +00:00
kwin: Use the new API for rendering quads
2013-03-21 22:52:03 +00:00
GLVertex2D *map = (GLVertex2D *) vbo->map(primcount * sizeof(GLVertex2D));
quads.makeInterleavedArrays(primitiveType, map, matrix);
kwin: Use the new map() interface in renderQuads() Write the vertex data directly into the buffer object, instead of allocating two temporary arrays, coyping the data into them, and then copying the data from the arrays into the buffer object. This also makes renderQuads() handle coordinates for rectangular textures correctly.
2012-09-18 20:24:58 +00:00
vbo->unmap();
kwin: Use the new API for rendering quads
2013-03-21 22:52:03 +00:00
vbo->render(region, primitiveType, m_hardwareClipping);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
GLTexture *SceneOpenGL::Window::textureForType(SceneOpenGL::Window::TextureType type)
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
GLTexture *tex = NULL;
kwin: Use texture atlases for the decorations Use two textures per window instead of four, storing the left and right borders in the first texture, and the top and bottom borders in the second. This makes it possible to render the whole decoration with only two calls to glDrawArrays(). It also reduces the number of texture allocations while resizing a window.
2013-03-15 17:01:44 +00:00
OpenGLPaintRedirector *redirector = NULL;
kwin: Refactor the decoration code a bit
2013-03-15 14:11:40 +00:00
OpenGLPaintRedirector updates textures directly Ownership of decoration textures is moved from SceneOpenGL::Window to OpenGLPaintRedirector. The PaintRedirector is responsible for updating the textures whenever they change. For this GLTexture is extended by an update(QImage, QPoint) method which uses glTexSubImage2D to update only the changed parts. The big advantage compared to before is that if e.g. only a button is animated only the button part is updated instead of the complete deco part.
2013-02-22 09:13:46 +00:00
if (type != Content && type != Shadow) {
if (toplevel->isClient()) {
kwin: Use texture atlases for the decorations Use two textures per window instead of four, storing the left and right borders in the first texture, and the top and bottom borders in the second. This makes it possible to render the whole decoration with only two calls to glDrawArrays(). It also reduces the number of texture allocations while resizing a window.
2013-03-15 17:01:44 +00:00
Client *client = static_cast<Client*>(toplevel);
redirector = static_cast<OpenGLPaintRedirector*>(client->decorationPaintRedirector());
OpenGLPaintRedirector updates textures directly Ownership of decoration textures is moved from SceneOpenGL::Window to OpenGLPaintRedirector. The PaintRedirector is responsible for updating the textures whenever they change. For this GLTexture is extended by an update(QImage, QPoint) method which uses glTexSubImage2D to update only the changed parts. The big advantage compared to before is that if e.g. only a button is animated only the button part is updated instead of the complete deco part.
2013-02-22 09:13:46 +00:00
} else if (toplevel->isDeleted()) {
kwin: Use texture atlases for the decorations Use two textures per window instead of four, storing the left and right borders in the first texture, and the top and bottom borders in the second. This makes it possible to render the whole decoration with only two calls to glDrawArrays(). It also reduces the number of texture allocations while resizing a window.
2013-03-15 17:01:44 +00:00
Deleted *deleted = static_cast<Deleted*>(toplevel);
redirector = static_cast<OpenGLPaintRedirector*>(deleted->decorationPaintRedirector());
OpenGLPaintRedirector updates textures directly Ownership of decoration textures is moved from SceneOpenGL::Window to OpenGLPaintRedirector. The PaintRedirector is responsible for updating the textures whenever they change. For this GLTexture is extended by an update(QImage, QPoint) method which uses glTexSubImage2D to update only the changed parts. The big advantage compared to before is that if e.g. only a button is animated only the button part is updated instead of the complete deco part.
2013-02-22 09:13:46 +00:00
}
}
kwin: Refactor the decoration code a bit
2013-03-15 14:11:40 +00:00
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
switch(type) {
case Content:
New class to encapsulate a Window's Pixmap The behavior for creating a pixmap for a window is moved from Toplevel into a dedicated class WindowPixmap. Scene::Window holds a reference to this class and creates a new WindowPixmap whenever the pixmap needs to be discarded. In addition it also keeps the old WindowPixmap around for the case that creating the new pixmap fails. The compositor can in that case use the previous pixmap which reduces possible flickering. Also this referencing can be used to improve transition effects like the maximize windows effect which would benefit from starting with the old pixmap. For XRender and OpenGL a dedicated sub-class of the WindowPixmap is created which provides the additional mapping to an XRender picture and OpenGL texture respectively. BUG: 319563 FIXED-IN: 4.11 REVIEW: 110577
2013-05-10 10:07:56 +00:00
tex = s_frameTexture;
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
break;
kwin: Refactor the decoration code a bit
2013-03-15 14:11:40 +00:00
kwin: Use texture atlases for the decorations Use two textures per window instead of four, storing the left and right borders in the first texture, and the top and bottom borders in the second. This makes it possible to render the whole decoration with only two calls to glDrawArrays(). It also reduces the number of texture allocations while resizing a window.
2013-03-15 17:01:44 +00:00
case DecorationLeftRight:
tex = redirector ? redirector->leftRightTexture() : 0;
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
break;
kwin: Refactor the decoration code a bit
2013-03-15 14:11:40 +00:00
kwin: Use texture atlases for the decorations Use two textures per window instead of four, storing the left and right borders in the first texture, and the top and bottom borders in the second. This makes it possible to render the whole decoration with only two calls to glDrawArrays(). It also reduces the number of texture allocations while resizing a window.
2013-03-15 17:01:44 +00:00
case DecorationTopBottom:
tex = redirector ? redirector->topBottomTexture() : 0;
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
break;
kwin: Refactor the decoration code a bit
2013-03-15 14:11:40 +00:00
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
case Shadow:
tex = static_cast<SceneOpenGLShadow*>(m_shadow)->shadowTexture();
}
return tex;
}
New class to encapsulate a Window's Pixmap The behavior for creating a pixmap for a window is moved from Toplevel into a dedicated class WindowPixmap. Scene::Window holds a reference to this class and creates a new WindowPixmap whenever the pixmap needs to be discarded. In addition it also keeps the old WindowPixmap around for the case that creating the new pixmap fails. The compositor can in that case use the previous pixmap which reduces possible flickering. Also this referencing can be used to improve transition effects like the maximize windows effect which would benefit from starting with the old pixmap. For XRender and OpenGL a dedicated sub-class of the WindowPixmap is created which provides the additional mapping to an XRender picture and OpenGL texture respectively. BUG: 319563 FIXED-IN: 4.11 REVIEW: 110577
2013-05-10 10:07:56 +00:00
WindowPixmap* SceneOpenGL::Window::createWindowPixmap()
{
return new OpenGLWindowPixmap(this, m_scene);
}
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
//***************************************
// SceneOpenGL2Window
//***************************************
SceneOpenGL2Window::SceneOpenGL2Window(Toplevel *c)
: SceneOpenGL::Window(c)
Decoration can announce whether it currently requires an alpha channel A decoration can provide the AbilityAnnounceAlphaChannel in addition to AbilityUsesAlphaChannel. If this ability is provided the decoration can enable/disable the use of the alpha channel through setAlphaEnabled(). The base idea behind this mechanism is to be able to tell the compositor that currently alpha is not needed. An example is the maximized state in which the decoration is fully opaque so that there is no need to use the translucency code path which would render all windows behind the deco. In addition also the blur effect honors this setting so that behind a known opaque decoration no blurring is performed. Oxygen is adjusted to disable translucency in maximized state and Aurorae is adjusted to allow themes to enable/disable translucency. For Plastik translucency and with that also blurring is disabled. REVIEW: 106810
2012-10-12 09:34:05 +00:00
, m_blendingEnabled(false)
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
{
}
SceneOpenGL2Window::~SceneOpenGL2Window()
{
}
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
QVector4D SceneOpenGL2Window::modulate(float opacity, float brightness) const
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
{
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
const float a = opacity;
const float rgb = opacity * brightness;
return QVector4D(rgb, rgb, rgb, a);
}
void SceneOpenGL2Window::setBlendEnabled(bool enabled)
{
if (enabled && !m_blendingEnabled)
glEnable(GL_BLEND);
else if (!enabled && m_blendingEnabled)
glDisable(GL_BLEND);
m_blendingEnabled = enabled;
}
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
void SceneOpenGL2Window::setupLeafNodes(LeafNode *nodes, const WindowQuadList *quads, const WindowPaintData &data)
{
if (!quads[ShadowLeaf].isEmpty()) {
nodes[ShadowLeaf].texture = static_cast<SceneOpenGLShadow *>(m_shadow)->shadowTexture();
nodes[ShadowLeaf].opacity = data.opacity();
nodes[ShadowLeaf].hasAlpha = true;
nodes[ShadowLeaf].coordinateType = NormalizedCoordinates;
}
if (!quads[LeftRightLeaf].isEmpty() || !quads[TopBottomLeaf].isEmpty()) {
GLTexture *textures[2];
getDecorationTextures(textures);
nodes[LeftRightLeaf].texture = textures[0];
Hotfix GL crossfading Not correct crossfading Purpose of the hotfix is to manipulate opacities of the "semi-crossfaded™" pixmaps so that on a quick animation and sloppy check it looks somehow believable (instead of bumping the window to full opacity) REVIEW: 111888
2013-08-05 13:12:08 +00:00
nodes[LeftRightLeaf].opacity = data.opacity();
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
nodes[LeftRightLeaf].hasAlpha = true;
nodes[LeftRightLeaf].coordinateType = UnnormalizedCoordinates;
nodes[TopBottomLeaf].texture = textures[1];
Hotfix GL crossfading Not correct crossfading Purpose of the hotfix is to manipulate opacities of the "semi-crossfaded™" pixmaps so that on a quick animation and sloppy check it looks somehow believable (instead of bumping the window to full opacity) REVIEW: 111888
2013-08-05 13:12:08 +00:00
nodes[TopBottomLeaf].opacity = data.opacity();
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
nodes[TopBottomLeaf].hasAlpha = true;
nodes[TopBottomLeaf].coordinateType = UnnormalizedCoordinates;
}
New class to encapsulate a Window's Pixmap The behavior for creating a pixmap for a window is moved from Toplevel into a dedicated class WindowPixmap. Scene::Window holds a reference to this class and creates a new WindowPixmap whenever the pixmap needs to be discarded. In addition it also keeps the old WindowPixmap around for the case that creating the new pixmap fails. The compositor can in that case use the previous pixmap which reduces possible flickering. Also this referencing can be used to improve transition effects like the maximize windows effect which would benefit from starting with the old pixmap. For XRender and OpenGL a dedicated sub-class of the WindowPixmap is created which provides the additional mapping to an XRender picture and OpenGL texture respectively. BUG: 319563 FIXED-IN: 4.11 REVIEW: 110577
2013-05-10 10:07:56 +00:00
nodes[ContentLeaf].texture = s_frameTexture;
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
nodes[ContentLeaf].hasAlpha = !isOpaque();
Hotfix GL crossfading Not correct crossfading Purpose of the hotfix is to manipulate opacities of the "semi-crossfaded™" pixmaps so that on a quick animation and sloppy check it looks somehow believable (instead of bumping the window to full opacity) REVIEW: 111888
2013-08-05 13:12:08 +00:00
// TODO: ARGB crsoofading is atm. a hack, playing on opacities for two dumb SrcOver operations
// Should be a shader
if (data.crossFadeProgress() != 1.0 && (data.opacity() < 0.95 || toplevel->hasAlpha())) {
const float opacity = 1.0 - data.crossFadeProgress();
nodes[ContentLeaf].opacity = data.opacity() * (1 - pow(opacity, 1.0f + 2.0f * data.opacity()));
} else {
nodes[ContentLeaf].opacity = data.opacity();
}
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
nodes[ContentLeaf].coordinateType = UnnormalizedCoordinates;
Introduce cross-fading with previous pixmap Cross fading with previous pixmap is achieved by referencing the old window pixmap. WindowPaintData has a cross-fade-factor which interpolates between 0.0 (completely old pixmap) to 1.0 (completely new pixmap). If a cross fading factor is set and a previous pixmap is valid this one is rendered on top of the current pixmap with opacity adjusted. This results in a smoother fading. To simplify the setup the AnimationEffect is extended and also takes care about correctly (un)referencing the previous window pixmap. The maximize effect is adjusted to make use of this new capabilities. Unfortunately this setup has a huge problem with the case that the window decoration gets smaller (e.g. from normal to maximized state). In this situation it can happen that the old window is rendered with parts outside the content resulting in video garbage being shown. To prevent this a set of new WindowQuads is generated with normalized texture coordinates in the safe area which contains real content. For OpenGL2Window a PreviousContentLeaf is added which is only set up in case the crass fading factor is set. REVIEW: 110578
2013-05-13 06:17:28 +00:00
if (data.crossFadeProgress() != 1.0) {
OpenGLWindowPixmap *previous = previousWindowPixmap<OpenGLWindowPixmap>();
nodes[PreviousContentLeaf].texture = previous ? previous->texture() : NULL;
nodes[PreviousContentLeaf].hasAlpha = !isOpaque();
Hotfix GL crossfading Not correct crossfading Purpose of the hotfix is to manipulate opacities of the "semi-crossfaded™" pixmaps so that on a quick animation and sloppy check it looks somehow believable (instead of bumping the window to full opacity) REVIEW: 111888
2013-08-05 13:12:08 +00:00
nodes[PreviousContentLeaf].opacity = data.opacity() * (1.0 - data.crossFadeProgress());
Introduce cross-fading with previous pixmap Cross fading with previous pixmap is achieved by referencing the old window pixmap. WindowPaintData has a cross-fade-factor which interpolates between 0.0 (completely old pixmap) to 1.0 (completely new pixmap). If a cross fading factor is set and a previous pixmap is valid this one is rendered on top of the current pixmap with opacity adjusted. This results in a smoother fading. To simplify the setup the AnimationEffect is extended and also takes care about correctly (un)referencing the previous window pixmap. The maximize effect is adjusted to make use of this new capabilities. Unfortunately this setup has a huge problem with the case that the window decoration gets smaller (e.g. from normal to maximized state). In this situation it can happen that the old window is rendered with parts outside the content resulting in video garbage being shown. To prevent this a set of new WindowQuads is generated with normalized texture coordinates in the safe area which contains real content. For OpenGL2Window a PreviousContentLeaf is added which is only set up in case the crass fading factor is set. REVIEW: 110578
2013-05-13 06:17:28 +00:00
nodes[PreviousContentLeaf].coordinateType = NormalizedCoordinates;
}
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
}
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
void SceneOpenGL2Window::performPaint(int mask, QRegion region, WindowPaintData data)
{
if (!beginRenderWindow(mask, region, data))
return;
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
GLShader *shader = data.shader;
if (!shader) {
if ((mask & Scene::PAINT_WINDOW_TRANSFORMED) || (mask & Scene::PAINT_SCREEN_TRANSFORMED)) {
shader = ShaderManager::instance()->pushShader(ShaderManager::GenericShader);
} else {
shader = ShaderManager::instance()->pushShader(ShaderManager::SimpleShader);
shader->setUniform(GLShader::Offset, QVector2D(x(), y()));
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
}
}
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
Only create ColorCorrection if it is enabled in the options According to massif just creating the ColorCorrection costs 2 MiB, so it makes sense to not create it if it is not used. REVIEW: 111604 DIGEST: Smaller memory footprint in KWin 4.11.2 if color correction is disabled
2013-09-04 12:42:45 +00:00
if (ColorCorrection *cc = static_cast<SceneOpenGL2*>(m_scene)->colorCorrection()) {
cc->setupForOutput(data.screen());
}
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
shader->setUniform(GLShader::WindowTransformation, transformation(mask, data));
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
shader->setUniform(GLShader::Saturation, data.saturation());
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
const GLenum filter = (mask & (Effect::PAINT_WINDOW_TRANSFORMED | Effect::PAINT_SCREEN_TRANSFORMED))
&& options->glSmoothScale() != 0 ? GL_LINEAR : GL_NEAREST;
Introduce cross-fading with previous pixmap Cross fading with previous pixmap is achieved by referencing the old window pixmap. WindowPaintData has a cross-fade-factor which interpolates between 0.0 (completely old pixmap) to 1.0 (completely new pixmap). If a cross fading factor is set and a previous pixmap is valid this one is rendered on top of the current pixmap with opacity adjusted. This results in a smoother fading. To simplify the setup the AnimationEffect is extended and also takes care about correctly (un)referencing the previous window pixmap. The maximize effect is adjusted to make use of this new capabilities. Unfortunately this setup has a huge problem with the case that the window decoration gets smaller (e.g. from normal to maximized state). In this situation it can happen that the old window is rendered with parts outside the content resulting in video garbage being shown. To prevent this a set of new WindowQuads is generated with normalized texture coordinates in the safe area which contains real content. For OpenGL2Window a PreviousContentLeaf is added which is only set up in case the crass fading factor is set. REVIEW: 110578
2013-05-13 06:17:28 +00:00
WindowQuadList quads[LeafCount];
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
// Split the quads into separate lists for each type
foreach (const WindowQuad &quad, data.quads) {
switch (quad.type()) {
case WindowQuadDecorationLeftRight:
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
quads[LeftRightLeaf].append(quad);
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
continue;
case WindowQuadDecorationTopBottom:
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
quads[TopBottomLeaf].append(quad);
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
continue;
case WindowQuadContents:
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
quads[ContentLeaf].append(quad);
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
continue;
case WindowQuadShadowTopLeft:
case WindowQuadShadowTop:
case WindowQuadShadowTopRight:
case WindowQuadShadowLeft:
case WindowQuadShadowRight:
case WindowQuadShadowBottomLeft:
case WindowQuadShadowBottom:
case WindowQuadShadowBottomRight:
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
quads[ShadowLeaf].append(quad);
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
continue;
default:
continue;
}
}
Introduce cross-fading with previous pixmap Cross fading with previous pixmap is achieved by referencing the old window pixmap. WindowPaintData has a cross-fade-factor which interpolates between 0.0 (completely old pixmap) to 1.0 (completely new pixmap). If a cross fading factor is set and a previous pixmap is valid this one is rendered on top of the current pixmap with opacity adjusted. This results in a smoother fading. To simplify the setup the AnimationEffect is extended and also takes care about correctly (un)referencing the previous window pixmap. The maximize effect is adjusted to make use of this new capabilities. Unfortunately this setup has a huge problem with the case that the window decoration gets smaller (e.g. from normal to maximized state). In this situation it can happen that the old window is rendered with parts outside the content resulting in video garbage being shown. To prevent this a set of new WindowQuads is generated with normalized texture coordinates in the safe area which contains real content. For OpenGL2Window a PreviousContentLeaf is added which is only set up in case the crass fading factor is set. REVIEW: 110578
2013-05-13 06:17:28 +00:00
if (data.crossFadeProgress() != 1.0) {
OpenGLWindowPixmap *previous = previousWindowPixmap<OpenGLWindowPixmap>();
if (previous) {
const QRect &oldGeometry = previous->contentsRect();
kwin : replace Q_FOREACH with for(a:b) replace Q_FOREACH loops with newer for (a:b) notation Signed-off-by: Laurent Navet <laurent.navet@gmail.com> REVIEW: 114222
2013-11-30 13:24:36 +00:00
for (const WindowQuad &quad : quads[ContentLeaf]) {
Introduce cross-fading with previous pixmap Cross fading with previous pixmap is achieved by referencing the old window pixmap. WindowPaintData has a cross-fade-factor which interpolates between 0.0 (completely old pixmap) to 1.0 (completely new pixmap). If a cross fading factor is set and a previous pixmap is valid this one is rendered on top of the current pixmap with opacity adjusted. This results in a smoother fading. To simplify the setup the AnimationEffect is extended and also takes care about correctly (un)referencing the previous window pixmap. The maximize effect is adjusted to make use of this new capabilities. Unfortunately this setup has a huge problem with the case that the window decoration gets smaller (e.g. from normal to maximized state). In this situation it can happen that the old window is rendered with parts outside the content resulting in video garbage being shown. To prevent this a set of new WindowQuads is generated with normalized texture coordinates in the safe area which contains real content. For OpenGL2Window a PreviousContentLeaf is added which is only set up in case the crass fading factor is set. REVIEW: 110578
2013-05-13 06:17:28 +00:00
// we need to create new window quads with normalize texture coordinates
// normal quads divide the x/y position by width/height. This would not work as the texture
// is larger than the visible content in case of a decorated Client resulting in garbage being shown.
// So we calculate the normalized texture coordinate in the Client's new content space and map it to
// the previous Client's content space.
WindowQuad newQuad(WindowQuadContents);
for (int i = 0; i < 4; ++i) {
const qreal xFactor = qreal(quad[i].textureX() - toplevel->clientPos().x())/qreal(toplevel->clientSize().width());
const qreal yFactor = qreal(quad[i].textureY() - toplevel->clientPos().y())/qreal(toplevel->clientSize().height());
WindowVertex vertex(quad[i].x(), quad[i].y(),
(xFactor * oldGeometry.width() + oldGeometry.x())/qreal(previous->size().width()),
(yFactor * oldGeometry.height() + oldGeometry.y())/qreal(previous->size().height()));
newQuad[i] = vertex;
}
quads[PreviousContentLeaf].append(newQuad);
}
}
}
kwin: Use the new API for rendering quads
2013-03-21 22:52:03 +00:00
const bool indexedQuads = GLVertexBuffer::supportsIndexedQuads();
const GLenum primitiveType = indexedQuads ? GL_QUADS_KWIN : GL_TRIANGLES;
const int verticesPerQuad = indexedQuads ? 4 : 6;
const size_t size = verticesPerQuad *
Introduce cross-fading with previous pixmap Cross fading with previous pixmap is achieved by referencing the old window pixmap. WindowPaintData has a cross-fade-factor which interpolates between 0.0 (completely old pixmap) to 1.0 (completely new pixmap). If a cross fading factor is set and a previous pixmap is valid this one is rendered on top of the current pixmap with opacity adjusted. This results in a smoother fading. To simplify the setup the AnimationEffect is extended and also takes care about correctly (un)referencing the previous window pixmap. The maximize effect is adjusted to make use of this new capabilities. Unfortunately this setup has a huge problem with the case that the window decoration gets smaller (e.g. from normal to maximized state). In this situation it can happen that the old window is rendered with parts outside the content resulting in video garbage being shown. To prevent this a set of new WindowQuads is generated with normalized texture coordinates in the safe area which contains real content. For OpenGL2Window a PreviousContentLeaf is added which is only set up in case the crass fading factor is set. REVIEW: 110578
2013-05-13 06:17:28 +00:00
(quads[0].count() + quads[1].count() + quads[2].count() + quads[3].count() + quads[4].count()) * sizeof(GLVertex2D);
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
GLVertex2D *map = (GLVertex2D *) vbo->map(size);
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
Introduce cross-fading with previous pixmap Cross fading with previous pixmap is achieved by referencing the old window pixmap. WindowPaintData has a cross-fade-factor which interpolates between 0.0 (completely old pixmap) to 1.0 (completely new pixmap). If a cross fading factor is set and a previous pixmap is valid this one is rendered on top of the current pixmap with opacity adjusted. This results in a smoother fading. To simplify the setup the AnimationEffect is extended and also takes care about correctly (un)referencing the previous window pixmap. The maximize effect is adjusted to make use of this new capabilities. Unfortunately this setup has a huge problem with the case that the window decoration gets smaller (e.g. from normal to maximized state). In this situation it can happen that the old window is rendered with parts outside the content resulting in video garbage being shown. To prevent this a set of new WindowQuads is generated with normalized texture coordinates in the safe area which contains real content. For OpenGL2Window a PreviousContentLeaf is added which is only set up in case the crass fading factor is set. REVIEW: 110578
2013-05-13 06:17:28 +00:00
LeafNode nodes[LeafCount];
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
setupLeafNodes(nodes, quads, data);
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
Introduce cross-fading with previous pixmap Cross fading with previous pixmap is achieved by referencing the old window pixmap. WindowPaintData has a cross-fade-factor which interpolates between 0.0 (completely old pixmap) to 1.0 (completely new pixmap). If a cross fading factor is set and a previous pixmap is valid this one is rendered on top of the current pixmap with opacity adjusted. This results in a smoother fading. To simplify the setup the AnimationEffect is extended and also takes care about correctly (un)referencing the previous window pixmap. The maximize effect is adjusted to make use of this new capabilities. Unfortunately this setup has a huge problem with the case that the window decoration gets smaller (e.g. from normal to maximized state). In this situation it can happen that the old window is rendered with parts outside the content resulting in video garbage being shown. To prevent this a set of new WindowQuads is generated with normalized texture coordinates in the safe area which contains real content. For OpenGL2Window a PreviousContentLeaf is added which is only set up in case the crass fading factor is set. REVIEW: 110578
2013-05-13 06:17:28 +00:00
for (int i = 0, v = 0; i < LeafCount; i++) {
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
if (quads[i].isEmpty() || !nodes[i].texture)
continue;
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
nodes[i].firstVertex = v;
kwin: Use the new API for rendering quads
2013-03-21 22:52:03 +00:00
nodes[i].vertexCount = quads[i].count() * verticesPerQuad;
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
const QMatrix4x4 matrix = nodes[i].texture->matrix(nodes[i].coordinateType);
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
kwin: Use the new API for rendering quads
2013-03-21 22:52:03 +00:00
quads[i].makeInterleavedArrays(primitiveType, &map[v], matrix);
v += quads[i].count() * verticesPerQuad;
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
}
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
vbo->unmap();
vbo->bindArrays();
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
// Make sure the blend function is set up correctly in case we will be doing blending
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
float opacity = -1.0;
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
Introduce cross-fading with previous pixmap Cross fading with previous pixmap is achieved by referencing the old window pixmap. WindowPaintData has a cross-fade-factor which interpolates between 0.0 (completely old pixmap) to 1.0 (completely new pixmap). If a cross fading factor is set and a previous pixmap is valid this one is rendered on top of the current pixmap with opacity adjusted. This results in a smoother fading. To simplify the setup the AnimationEffect is extended and also takes care about correctly (un)referencing the previous window pixmap. The maximize effect is adjusted to make use of this new capabilities. Unfortunately this setup has a huge problem with the case that the window decoration gets smaller (e.g. from normal to maximized state). In this situation it can happen that the old window is rendered with parts outside the content resulting in video garbage being shown. To prevent this a set of new WindowQuads is generated with normalized texture coordinates in the safe area which contains real content. For OpenGL2Window a PreviousContentLeaf is added which is only set up in case the crass fading factor is set. REVIEW: 110578
2013-05-13 06:17:28 +00:00
for (int i = 0; i < LeafCount; i++) {
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
if (nodes[i].vertexCount == 0)
continue;
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
setBlendEnabled(nodes[i].hasAlpha || nodes[i].opacity < 1.0);
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
if (opacity != nodes[i].opacity) {
shader->setUniform(GLShader::ModulationConstant,
modulate(nodes[i].opacity, data.brightness()));
opacity = nodes[i].opacity;
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
}
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
nodes[i].texture->setFilter(filter);
nodes[i].texture->setWrapMode(GL_CLAMP_TO_EDGE);
nodes[i].texture->bind();
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
kwin: Use the new API for rendering quads
2013-03-21 22:52:03 +00:00
vbo->draw(region, primitiveType, nodes[i].firstVertex, nodes[i].vertexCount, m_hardwareClipping);
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
}
kwin: Upload all the vertex data at the same time With this change we only map the vertex buffer once per window. The vertex arrays are also only set up once.
2013-03-18 15:45:53 +00:00
vbo->unbindArrays();
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
setBlendEnabled(false);
if (!data.shader)
ShaderManager::instance()->popShader();
endRenderWindow();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
void SceneOpenGL2Window::prepareStates(TextureType type, qreal opacity, qreal brightness, qreal saturation, int screen)
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
// setup blending of transparent windows
Separate rendering for decoration and window contents, they can have different opacity (opacity only for decoration option). svn path=/trunk/KDE/kdebase/workspace/; revision=689855
2007-07-19 10:07:49 +00:00
bool opaque = isOpaque() && opacity == 1.0;
Fix blend func for shaders svn path=/trunk/KDE/kdebase/workspace/; revision=1203714
2010-12-05 10:02:47 +00:00
bool alpha = toplevel->hasAlpha() || type != Content;
Decoration can announce whether it currently requires an alpha channel A decoration can provide the AbilityAnnounceAlphaChannel in addition to AbilityUsesAlphaChannel. If this ability is provided the decoration can enable/disable the use of the alpha channel through setAlphaEnabled(). The base idea behind this mechanism is to be able to tell the compositor that currently alpha is not needed. An example is the maximized state in which the decoration is fully opaque so that there is no need to use the translucency code path which would render all windows behind the deco. In addition also the blur effect honors this setting so that behind a known opaque decoration no blurring is performed. Oxygen is adjusted to disable translucency in maximized state and Aurorae is adjusted to allow themes to enable/disable translucency. For Plastik translucency and with that also blurring is disabled. REVIEW: 106810
2012-10-12 09:34:05 +00:00
if (type != Content) {
if (type == Shadow) {
opaque = false;
} else {
if (opacity == 1.0 && toplevel->isClient()) {
opaque = !(static_cast<Client*>(toplevel)->decorationHasAlpha());
} else {
// TODO: add support in Deleted
opaque = false;
}
}
}
Fix blend func for shaders svn path=/trunk/KDE/kdebase/workspace/; revision=1203714
2010-12-05 10:02:47 +00:00
if (!opaque) {
glEnable(GL_BLEND);
Fix premultiplied alpha issue with color correction When correcting a color that was with premultiplied alpha, the alpha value was not multiplied back again as a final step. This was breaking color correction when the blend function was GL_ONE, GL_ONE_MINUS_SRC_ALPHA. The blend function was changed for normal windows (a workaround), but not for effect frames, i.e. the effect frames were broken with color correction enabled. Removes the blend function workaround. Removes a useless setupForOutput. BUG: 311319 REVIEW: 108189
2013-01-05 03:39:02 +00:00
if (alpha) {
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
Fix blend func for shaders svn path=/trunk/KDE/kdebase/workspace/; revision=1203714
2010-12-05 10:02:47 +00:00
} else {
Fix premultiplied alpha issue with color correction When correcting a color that was with premultiplied alpha, the alpha value was not multiplied back again as a final step. This was breaking color correction when the blend function was GL_ONE, GL_ONE_MINUS_SRC_ALPHA. The blend function was changed for normal windows (a workaround), but not for effect frames, i.e. the effect frames were broken with color correction enabled. Removes the blend function workaround. Removes a useless setupForOutput. BUG: 311319 REVIEW: 108189
2013-01-05 03:39:02 +00:00
glBlendColor((float)opacity, (float)opacity, (float)opacity, (float)opacity);
glBlendFunc(GL_ONE, GL_ONE_MINUS_CONSTANT_ALPHA);
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
}
Fix blend func for shaders svn path=/trunk/KDE/kdebase/workspace/; revision=1203714
2010-12-05 10:02:47 +00:00
}
Decoration can announce whether it currently requires an alpha channel A decoration can provide the AbilityAnnounceAlphaChannel in addition to AbilityUsesAlphaChannel. If this ability is provided the decoration can enable/disable the use of the alpha channel through setAlphaEnabled(). The base idea behind this mechanism is to be able to tell the compositor that currently alpha is not needed. An example is the maximized state in which the decoration is fully opaque so that there is no need to use the translucency code path which would render all windows behind the deco. In addition also the blur effect honors this setting so that behind a known opaque decoration no blurring is performed. Oxygen is adjusted to disable translucency in maximized state and Aurorae is adjusted to allow themes to enable/disable translucency. For Plastik translucency and with that also blurring is disabled. REVIEW: 106810
2012-10-12 09:34:05 +00:00
m_blendingEnabled = !opaque;
kwin: Replace brightness and opacity with a modulation constant This makes it possible to adjust both brightness and opacity at the same time with one multiplication in the fragment shader.
2011-02-12 00:36:21 +00:00
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
const qreal rgb = brightness * opacity;
const qreal a = opacity;
kwin: Replace brightness and opacity with a modulation constant This makes it possible to adjust both brightness and opacity at the same time with one multiplication in the fragment shader.
2011-02-12 00:36:21 +00:00
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
GLShader *shader = ShaderManager::instance()->getBoundShader();
kwin: Replace brightness and opacity with a modulation constant This makes it possible to adjust both brightness and opacity at the same time with one multiplication in the fragment shader.
2011-02-12 00:36:21 +00:00
shader->setUniform(GLShader::ModulationConstant, QVector4D(rgb, rgb, rgb, a));
shader->setUniform(GLShader::Saturation, saturation);
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
Only create ColorCorrection if it is enabled in the options According to massif just creating the ColorCorrection costs 2 MiB, so it makes sense to not create it if it is not used. REVIEW: 111604 DIGEST: Smaller memory footprint in KWin 4.11.2 if color correction is disabled
2013-09-04 12:42:45 +00:00
if (ColorCorrection *cc = static_cast<SceneOpenGL2*>(m_scene)->colorCorrection()) {
cc->setupForOutput(screen);
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
Revert "Merge branch 'color2'" This merge is incomplete and it does not include the review number of the associated review request. It should have been pushed as a single commit, because the merged commits were not intended to be published in their form. This reverts commit dcba90263069a221a5489b1915c5cf1ca39d090c, reversing changes made to 50ae07525c7fde07794e7548c3d6e5a69cb1a89d. Conflicts: kwin/scene_opengl.cpp kwin/scene_opengl.h
2012-11-13 20:19:01 +00:00
void SceneOpenGL2Window::restoreStates(TextureType type, qreal opacity, qreal brightness, qreal saturation)
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Decoration can announce whether it currently requires an alpha channel A decoration can provide the AbilityAnnounceAlphaChannel in addition to AbilityUsesAlphaChannel. If this ability is provided the decoration can enable/disable the use of the alpha channel through setAlphaEnabled(). The base idea behind this mechanism is to be able to tell the compositor that currently alpha is not needed. An example is the maximized state in which the decoration is fully opaque so that there is no need to use the translucency code path which would render all windows behind the deco. In addition also the blur effect honors this setting so that behind a known opaque decoration no blurring is performed. Oxygen is adjusted to disable translucency in maximized state and Aurorae is adjusted to allow themes to enable/disable translucency. For Plastik translucency and with that also blurring is disabled. REVIEW: 106810
2012-10-12 09:34:05 +00:00
Q_UNUSED(type);
Q_UNUSED(opacity);
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
Q_UNUSED(brightness);
Q_UNUSED(saturation);
Decoration can announce whether it currently requires an alpha channel A decoration can provide the AbilityAnnounceAlphaChannel in addition to AbilityUsesAlphaChannel. If this ability is provided the decoration can enable/disable the use of the alpha channel through setAlphaEnabled(). The base idea behind this mechanism is to be able to tell the compositor that currently alpha is not needed. An example is the maximized state in which the decoration is fully opaque so that there is no need to use the translucency code path which would render all windows behind the deco. In addition also the blur effect honors this setting so that behind a known opaque decoration no blurring is performed. Oxygen is adjusted to disable translucency in maximized state and Aurorae is adjusted to allow themes to enable/disable translucency. For Plastik translucency and with that also blurring is disabled. REVIEW: 106810
2012-10-12 09:34:05 +00:00
if (m_blendingEnabled) {
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
glDisable(GL_BLEND);
}
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
Only create ColorCorrection if it is enabled in the options According to massif just creating the ColorCorrection costs 2 MiB, so it makes sense to not create it if it is not used. REVIEW: 111604 DIGEST: Smaller memory footprint in KWin 4.11.2 if color correction is disabled
2013-09-04 12:42:45 +00:00
if (ColorCorrection *cc = static_cast<SceneOpenGL2*>(m_scene)->colorCorrection()) {
cc->setupForOutput(-1);
}
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
}
//***************************************
// SceneOpenGL1Window
//***************************************
Introduce a build option KWIN_BUILD_OPENGL_1_COMPOSITING If the build option is enabled KWIN_HAVE_OPENGL_1 is passed as a compile flag when build against OpenGL. This compile flag is meant to replace the KWIN_HAVE_OPENGLES. So far code has been ifdefed for special behavior of OpenGL ES 2.0 and to remove fixed functionality calls which are not available in OpenGL ES 2.0. With this build flag the fixed functionality calls which are only used in the OpenGL1 Compositor can be removed and keeping the KWIN_HAVE_OPENGLES for the real differences between OpenGL 2.x and OpenGL ES 2.0. E.g. a call like glColor4f should be in an glColor4f(1.0, 1.0, 1.0, 1.0); while a call like glPolygonMode should be in an glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); Building for OpenGL ES 2.0 of course implies that KWIN_HAVE_OPENGL_1 is not defined.
2012-10-05 08:45:10 +00:00
#ifdef KWIN_HAVE_OPENGL_1
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
SceneOpenGL1Window::SceneOpenGL1Window(Toplevel *c)
: SceneOpenGL::Window(c)
{
}
SceneOpenGL1Window::~SceneOpenGL1Window()
{
}
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
// paint the window
void SceneOpenGL1Window::performPaint(int mask, QRegion region, WindowPaintData data)
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
{
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
if (!beginRenderWindow(mask, region, data))
return;
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
pushMatrix(transformation(mask, data));
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
// shadow
if (m_shadow) {
paintShadow(region, data);
}
// decorations
paintDecorations(data, region);
// paint the content
Introduce cross-fading with previous pixmap Cross fading with previous pixmap is achieved by referencing the old window pixmap. WindowPaintData has a cross-fade-factor which interpolates between 0.0 (completely old pixmap) to 1.0 (completely new pixmap). If a cross fading factor is set and a previous pixmap is valid this one is rendered on top of the current pixmap with opacity adjusted. This results in a smoother fading. To simplify the setup the AnimationEffect is extended and also takes care about correctly (un)referencing the previous window pixmap. The maximize effect is adjusted to make use of this new capabilities. Unfortunately this setup has a huge problem with the case that the window decoration gets smaller (e.g. from normal to maximized state). In this situation it can happen that the old window is rendered with parts outside the content resulting in video garbage being shown. To prevent this a set of new WindowQuads is generated with normalized texture coordinates in the safe area which contains real content. For OpenGL2Window a PreviousContentLeaf is added which is only set up in case the crass fading factor is set. REVIEW: 110578
2013-05-13 06:17:28 +00:00
OpenGLWindowPixmap *previous = previousWindowPixmap<OpenGLWindowPixmap>();
const WindowQuadList contentQuads = data.quads.select(WindowQuadContents);
if (previous && data.crossFadeProgress() != 1.0) {
Hotfix GL crossfading Not correct crossfading Purpose of the hotfix is to manipulate opacities of the "semi-crossfaded™" pixmaps so that on a quick animation and sloppy check it looks somehow believable (instead of bumping the window to full opacity) REVIEW: 111888
2013-08-05 13:12:08 +00:00
// TODO: ARGB crsoofading is atm. a hack, playing on opacities for two dumb SrcOver operations
// Will require a caching texture or sth. else 1.2 compliant
float opacity = data.opacity();
if (opacity < 0.95f || toplevel->hasAlpha()) {
opacity = 1 - data.crossFadeProgress();
opacity = data.opacity() * (1 - pow(opacity, 1.0f + 2.0f * data.opacity()));
}
paintContent(s_frameTexture, region, mask, opacity, data, contentQuads, false);
Introduce cross-fading with previous pixmap Cross fading with previous pixmap is achieved by referencing the old window pixmap. WindowPaintData has a cross-fade-factor which interpolates between 0.0 (completely old pixmap) to 1.0 (completely new pixmap). If a cross fading factor is set and a previous pixmap is valid this one is rendered on top of the current pixmap with opacity adjusted. This results in a smoother fading. To simplify the setup the AnimationEffect is extended and also takes care about correctly (un)referencing the previous window pixmap. The maximize effect is adjusted to make use of this new capabilities. Unfortunately this setup has a huge problem with the case that the window decoration gets smaller (e.g. from normal to maximized state). In this situation it can happen that the old window is rendered with parts outside the content resulting in video garbage being shown. To prevent this a set of new WindowQuads is generated with normalized texture coordinates in the safe area which contains real content. For OpenGL2Window a PreviousContentLeaf is added which is only set up in case the crass fading factor is set. REVIEW: 110578
2013-05-13 06:17:28 +00:00
previous->texture()->setFilter(filter == Scene::ImageFilterGood ? GL_LINEAR : GL_NEAREST);
WindowQuadList oldContents;
const QRect &oldGeometry = previous->contentsRect();
kwin : replace Q_FOREACH with for(a:b) replace Q_FOREACH loops with newer for (a:b) notation Signed-off-by: Laurent Navet <laurent.navet@gmail.com> REVIEW: 114222
2013-11-30 13:24:36 +00:00
for (const WindowQuad &quad : contentQuads) {
Introduce cross-fading with previous pixmap Cross fading with previous pixmap is achieved by referencing the old window pixmap. WindowPaintData has a cross-fade-factor which interpolates between 0.0 (completely old pixmap) to 1.0 (completely new pixmap). If a cross fading factor is set and a previous pixmap is valid this one is rendered on top of the current pixmap with opacity adjusted. This results in a smoother fading. To simplify the setup the AnimationEffect is extended and also takes care about correctly (un)referencing the previous window pixmap. The maximize effect is adjusted to make use of this new capabilities. Unfortunately this setup has a huge problem with the case that the window decoration gets smaller (e.g. from normal to maximized state). In this situation it can happen that the old window is rendered with parts outside the content resulting in video garbage being shown. To prevent this a set of new WindowQuads is generated with normalized texture coordinates in the safe area which contains real content. For OpenGL2Window a PreviousContentLeaf is added which is only set up in case the crass fading factor is set. REVIEW: 110578
2013-05-13 06:17:28 +00:00
// we need to create new window quads with normalize texture coordinates
// normal quads divide the x/y position by width/height. This would not work as the texture
// is larger than the visible content in case of a decorated Client resulting in garbage being shown.
// So we calculate the normalized texture coordinate in the Client's new content space and map it to
// the previous Client's content space.
WindowQuad newQuad(WindowQuadContents);
for (int i = 0; i < 4; ++i) {
const qreal xFactor = qreal(quad[i].textureX() - toplevel->clientPos().x())/qreal(toplevel->clientSize().width());
const qreal yFactor = qreal(quad[i].textureY() - toplevel->clientPos().y())/qreal(toplevel->clientSize().height());
WindowVertex vertex(quad[i].x(), quad[i].y(),
(xFactor * oldGeometry.width() + oldGeometry.x())/qreal(previous->size().width()),
(yFactor * oldGeometry.height() + oldGeometry.y())/qreal(previous->size().height()));
newQuad[i] = vertex;
}
oldContents.append(newQuad);
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
}
Hotfix GL crossfading Not correct crossfading Purpose of the hotfix is to manipulate opacities of the "semi-crossfaded™" pixmaps so that on a quick animation and sloppy check it looks somehow believable (instead of bumping the window to full opacity) REVIEW: 111888
2013-08-05 13:12:08 +00:00
opacity = data.opacity() * (1.0 - data.crossFadeProgress());
paintContent(previous->texture(), region, mask, opacity, data, oldContents, true);
Introduce cross-fading with previous pixmap Cross fading with previous pixmap is achieved by referencing the old window pixmap. WindowPaintData has a cross-fade-factor which interpolates between 0.0 (completely old pixmap) to 1.0 (completely new pixmap). If a cross fading factor is set and a previous pixmap is valid this one is rendered on top of the current pixmap with opacity adjusted. This results in a smoother fading. To simplify the setup the AnimationEffect is extended and also takes care about correctly (un)referencing the previous window pixmap. The maximize effect is adjusted to make use of this new capabilities. Unfortunately this setup has a huge problem with the case that the window decoration gets smaller (e.g. from normal to maximized state). In this situation it can happen that the old window is rendered with parts outside the content resulting in video garbage being shown. To prevent this a set of new WindowQuads is generated with normalized texture coordinates in the safe area which contains real content. For OpenGL2Window a PreviousContentLeaf is added which is only set up in case the crass fading factor is set. REVIEW: 110578
2013-05-13 06:17:28 +00:00
} else {
paintContent(s_frameTexture, region, mask, data.opacity(), data, contentQuads, false);
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
}
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
popMatrix();
kwin: Refactor SceneOpenGL::Window Reimplement performPaint() in SceneOpenGL1Window and SceneOpenGL2Window. The roles between begin/endRenderWindow() and performPaint() are now reversed; performPaint() contains the specialized code while begin/ endRenderWindow() contains the shared code. This reduces the state churn in the OpenGL2 backend from the repeated calls to prepare/restoreStates().
2013-03-17 12:34:26 +00:00
endRenderWindow();
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
}
Introduce cross-fading with previous pixmap Cross fading with previous pixmap is achieved by referencing the old window pixmap. WindowPaintData has a cross-fade-factor which interpolates between 0.0 (completely old pixmap) to 1.0 (completely new pixmap). If a cross fading factor is set and a previous pixmap is valid this one is rendered on top of the current pixmap with opacity adjusted. This results in a smoother fading. To simplify the setup the AnimationEffect is extended and also takes care about correctly (un)referencing the previous window pixmap. The maximize effect is adjusted to make use of this new capabilities. Unfortunately this setup has a huge problem with the case that the window decoration gets smaller (e.g. from normal to maximized state). In this situation it can happen that the old window is rendered with parts outside the content resulting in video garbage being shown. To prevent this a set of new WindowQuads is generated with normalized texture coordinates in the safe area which contains real content. For OpenGL2Window a PreviousContentLeaf is added which is only set up in case the crass fading factor is set. REVIEW: 110578
2013-05-13 06:17:28 +00:00
void SceneOpenGL1Window::paintContent(SceneOpenGL::Texture* content, const QRegion& region, int mask,
qreal opacity, const WindowPaintData& data, const WindowQuadList &contentQuads, bool normalized)
{
if (contentQuads.isEmpty()) {
return;
}
content->bind();
prepareStates(Content, opacity, data.brightness(), data.saturation(), data.screen());
renderQuads(mask, region, contentQuads, content, normalized);
restoreStates(Content, opacity, data.brightness(), data.saturation());
content->unbind();
#ifndef KWIN_HAVE_OPENGLES
if (m_scene && m_scene->debug()) {
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
renderQuads(mask, region, contentQuads, content, normalized);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
#endif
}
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
void SceneOpenGL1Window::prepareStates(TextureType type, qreal opacity, qreal brightness, qreal saturation, int screen)
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
{
Implement color correction (per output) Add an option to kcmcompositing in the 'Advanced' tab, to enable or disable color correction. It is specified that it's experimental and it needs Kolor Manager. Before painting for a particular screen, ColorCorrection::setupForOutput should be called. A screen property is added for WindowPaintData. In kwinglutils, The fragment shaders are intercepted before being compiled and they get a couple of lines of code inserted in order to do the color correction. This happens only when color correction is enabled, of course. For D-Bus communication with KolorServer, everything is async. The implementation basically manages a set of color lookup tables for different outputs and for different window regions. These are taken via D-Bus. Each lookup table has around 700 KB. This commit reintroduces the changes from the former merge with the "color2" branch. In this form, it can be easily reverted. REVIEW: 106141
2012-11-13 20:41:02 +00:00
Q_UNUSED(screen)
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
GLTexture *tex = textureForType(type);
OpenGL part of ARGB decorations. See revision 957680 for more information. svn path=/trunk/KDE/kdebase/workspace/; revision=957681
2009-04-22 17:30:49 +00:00
bool alpha = false;
bool opaque = true;
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
if (type == Content) {
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
alpha = toplevel->hasAlpha();
opaque = isOpaque() && opacity == 1.0;
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
} else {
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
alpha = true;
opaque = false;
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
// setup blending of transparent windows
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glPushAttrib(GL_ENABLE_BIT);
if (!opaque) {
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
}
if (saturation != 1.0 && tex->saturationSupported()) {
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
// First we need to get the color from [0; 1] range to [0.5; 1] range
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glActiveTexture(GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_ALPHA);
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
const float scale_constant[] = { 1.0, 1.0, 1.0, 0.5};
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, scale_constant);
OpenGL part of ARGB decorations. See revision 957680 for more information. svn path=/trunk/KDE/kdebase/workspace/; revision=957681
2009-04-22 17:30:49 +00:00
tex->bind();
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
// Then we take dot product of the result of previous pass and
// saturation_constant. This gives us completely unsaturated
// (greyscale) image
// Note that both operands have to be in range [0.5; 1] since opengl
// automatically substracts 0.5 from them
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glActiveTexture(GL_TEXTURE1);
Fix more C++11 narrowing warnings REVIEW: 106997
2012-10-23 21:16:29 +00:00
float saturation_constant[] = { 0.5 + 0.5 * 0.30, 0.5 + 0.5 * 0.59, 0.5 + 0.5 * 0.11,
static_cast<float>(saturation) };
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_DOT3_RGB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, saturation_constant);
OpenGL part of ARGB decorations. See revision 957680 for more information. svn path=/trunk/KDE/kdebase/workspace/; revision=957681
2009-04-22 17:30:49 +00:00
tex->bind();
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
// Finally we need to interpolate between the original image and the
// greyscale image to get wanted level of saturation
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glActiveTexture(GL_TEXTURE2);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_ALPHA);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, saturation_constant);
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
// Also replace alpha by primary color's alpha here
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
// And make primary color contain the wanted opacity
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glColor4f(opacity, opacity, opacity, opacity);
OpenGL part of ARGB decorations. See revision 957680 for more information. svn path=/trunk/KDE/kdebase/workspace/; revision=957681
2009-04-22 17:30:49 +00:00
tex->bind();
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
fix GL1.2 saturation modulation for non opaques whether a window is ARGB or just not opaque does not matter BUG: 319091 FIXED-IN: 4.11 REVIEW: 111433
2013-07-07 19:14:06 +00:00
if (alpha || !opaque || brightness != 1.0f) {
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glActiveTexture(GL_TEXTURE3);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
X ARGB windows are stored with alpha premultiplied. Adjusted OpenGL rendering to accomodate that and therefore fixed incorrect rendering of windows with transparencies such as the Plasma panel. BUG: 163054 svn path=/trunk/KDE/kdebase/workspace/; revision=841974
2008-08-04 11:34:40 +00:00
// The color has to be multiplied by both opacity and brightness
float opacityByBrightness = opacity * brightness;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glColor4f(opacityByBrightness, opacityByBrightness, opacityByBrightness, opacity);
if (alpha) {
X ARGB windows are stored with alpha premultiplied. Adjusted OpenGL rendering to accomodate that and therefore fixed incorrect rendering of windows with transparencies such as the Plasma panel. BUG: 163054 svn path=/trunk/KDE/kdebase/workspace/; revision=841974
2008-08-04 11:34:40 +00:00
// Multiply original texture's alpha by our opacity
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
} else {
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
// Alpha will be taken from previous stage
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
tex->bind();
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glActiveTexture(GL_TEXTURE0);
} else if (opacity != 1.0 || brightness != 1.0) {
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
// the window is additionally configured to have its opacity adjusted,
// do it
X ARGB windows are stored with alpha premultiplied. Adjusted OpenGL rendering to accomodate that and therefore fixed incorrect rendering of windows with transparencies such as the Plasma panel. BUG: 163054 svn path=/trunk/KDE/kdebase/workspace/; revision=841974
2008-08-04 11:34:40 +00:00
float opacityByBrightness = opacity * brightness;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (alpha) {
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glColor4f(opacityByBrightness, opacityByBrightness, opacityByBrightness,
opacity);
} else {
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
// Multiply color by brightness and replace alpha by opacity
Fix more C++11 narrowing warnings REVIEW: 106997
2012-10-23 21:16:29 +00:00
float constant[] = { opacityByBrightness, opacityByBrightness, opacityByBrightness,
static_cast<float>(opacity) };
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_CONSTANT);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
} else if (!alpha && opaque) {
Make the new taskbar thumbnail shader work with NVIDIA driver. Therefore the alpha channel has to be added to oqaque windows in scene_opengl. svn path=/trunk/KDE/kdebase/workspace/; revision=1130622
2010-05-25 20:28:23 +00:00
float constant[] = { 1.0, 1.0, 1.0, 1.0 };
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_CONSTANT);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
Revert "Merge branch 'color2'" This merge is incomplete and it does not include the review number of the associated review request. It should have been pushed as a single commit, because the merged commits were not intended to be published in their form. This reverts commit dcba90263069a221a5489b1915c5cf1ca39d090c, reversing changes made to 50ae07525c7fde07794e7548c3d6e5a69cb1a89d. Conflicts: kwin/scene_opengl.cpp kwin/scene_opengl.h
2012-11-13 20:19:01 +00:00
void SceneOpenGL1Window::restoreStates(TextureType type, qreal opacity, qreal brightness, qreal saturation)
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
GLTexture *tex = textureForType(type);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (opacity != 1.0 || saturation != 1.0 || brightness != 1.0f) {
if (saturation != 1.0 && tex->saturationSupported()) {
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
glActiveTexture(GL_TEXTURE3);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glDisable(tex->target());
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
glActiveTexture(GL_TEXTURE2);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glDisable(tex->target());
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
glActiveTexture(GL_TEXTURE1);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glDisable(tex->target());
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
glActiveTexture(GL_TEXTURE0);
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glColor4f(0, 0, 0, 0);
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
glPopAttrib(); // ENABLE_BIT
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Split SceneOpenGL::Window into specific classes for OpenGL 1 and 2 The Window implementation performed many checks whether the rendering uses the OpenGL 1 or OpenGL 2 code path and there were quite a few cludges around to make this work. So instead of many if-else blocks the specific code has now been moved into a specific sub class and calls to pure virtual method in the base class are used to trigger this behavior. Although that adds some overhead in a rather hot code path it should be better than the many chained method calls used before to handle OpenGL 1 and 2. It also makes the code a little bit more readable as all the complete OpenGL 1 implementation is now in one block ifdefed for OpenGL ES.
2012-09-06 10:25:55 +00:00
#endif
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
New class to encapsulate a Window's Pixmap The behavior for creating a pixmap for a window is moved from Toplevel into a dedicated class WindowPixmap. Scene::Window holds a reference to this class and creates a new WindowPixmap whenever the pixmap needs to be discarded. In addition it also keeps the old WindowPixmap around for the case that creating the new pixmap fails. The compositor can in that case use the previous pixmap which reduces possible flickering. Also this referencing can be used to improve transition effects like the maximize windows effect which would benefit from starting with the old pixmap. For XRender and OpenGL a dedicated sub-class of the WindowPixmap is created which provides the additional mapping to an XRender picture and OpenGL texture respectively. BUG: 319563 FIXED-IN: 4.11 REVIEW: 110577
2013-05-10 10:07:56 +00:00
//****************************************
// OpenGLWindowPixmap
//****************************************
OpenGLWindowPixmap::OpenGLWindowPixmap(Scene::Window *window, SceneOpenGL* scene)
: WindowPixmap(window)
, m_scene(scene)
, m_texture(scene->createTexture())
{
}
OpenGLWindowPixmap::~OpenGLWindowPixmap()
{
}
bool OpenGLWindowPixmap::bind()
{
if (!m_texture->isNull()) {
if (!toplevel()->damage().isEmpty()) {
Egl Backend using a Wayland surface for rendering This backend is able to composite on a Wayland surface instead of an X11 overlay window. It can be considered as a prototype for a Wayland session compositor. For texture from X11 pixmap the backend uses XShm. This is far from optimal, but the KHR_image_pixmap extension is not available in Mesa's Wayland backend. It's a temporary solution till we have XWayland and texture from Wayland buffer. To use this backend one needs to specify the environment variable KWIN_OPENGL_INTERFACE with "egl_wayland". In future KWin should probably use this backend if the Wayland display env variable is defined. To use this setup: 1. Have a normal X-Server running on e.g. VT7 2. Start Weston on VT1 3. Start a terminal on Weston 4. start KWin with: DISPLAY=:0 KWIN_OPENGL_INTERFACE=egl_wayland kwin --replace & This should map a Wayland surface to Weston showing the content of the X setup. At the moment it's not yet possible to interact with the surface as input events are not yet recieved in the backend. There are still a lot of limitations as documented in the code.
2013-05-15 11:47:27 +00:00
const bool success = m_texture->update(toplevel()->damage());
New class to encapsulate a Window's Pixmap The behavior for creating a pixmap for a window is moved from Toplevel into a dedicated class WindowPixmap. Scene::Window holds a reference to this class and creates a new WindowPixmap whenever the pixmap needs to be discarded. In addition it also keeps the old WindowPixmap around for the case that creating the new pixmap fails. The compositor can in that case use the previous pixmap which reduces possible flickering. Also this referencing can be used to improve transition effects like the maximize windows effect which would benefit from starting with the old pixmap. For XRender and OpenGL a dedicated sub-class of the WindowPixmap is created which provides the additional mapping to an XRender picture and OpenGL texture respectively. BUG: 319563 FIXED-IN: 4.11 REVIEW: 110577
2013-05-10 10:07:56 +00:00
// mipmaps need to be updated
m_texture->setDirty();
toplevel()->resetDamage();
Egl Backend using a Wayland surface for rendering This backend is able to composite on a Wayland surface instead of an X11 overlay window. It can be considered as a prototype for a Wayland session compositor. For texture from X11 pixmap the backend uses XShm. This is far from optimal, but the KHR_image_pixmap extension is not available in Mesa's Wayland backend. It's a temporary solution till we have XWayland and texture from Wayland buffer. To use this backend one needs to specify the environment variable KWIN_OPENGL_INTERFACE with "egl_wayland". In future KWin should probably use this backend if the Wayland display env variable is defined. To use this setup: 1. Have a normal X-Server running on e.g. VT7 2. Start Weston on VT1 3. Start a terminal on Weston 4. start KWin with: DISPLAY=:0 KWIN_OPENGL_INTERFACE=egl_wayland kwin --replace & This should map a Wayland surface to Weston showing the content of the X setup. At the moment it's not yet possible to interact with the surface as input events are not yet recieved in the backend. There are still a lot of limitations as documented in the code.
2013-05-15 11:47:27 +00:00
return success;
New class to encapsulate a Window's Pixmap The behavior for creating a pixmap for a window is moved from Toplevel into a dedicated class WindowPixmap. Scene::Window holds a reference to this class and creates a new WindowPixmap whenever the pixmap needs to be discarded. In addition it also keeps the old WindowPixmap around for the case that creating the new pixmap fails. The compositor can in that case use the previous pixmap which reduces possible flickering. Also this referencing can be used to improve transition effects like the maximize windows effect which would benefit from starting with the old pixmap. For XRender and OpenGL a dedicated sub-class of the WindowPixmap is created which provides the additional mapping to an XRender picture and OpenGL texture respectively. BUG: 319563 FIXED-IN: 4.11 REVIEW: 110577
2013-05-10 10:07:56 +00:00
}
return true;
}
if (!isValid()) {
return false;
}
bool success = m_texture->load(pixmap(), toplevel()->size(), toplevel()->depth(), toplevel()->damage());
if (success)
toplevel()->resetDamage();
else
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "Failed to bind window";
New class to encapsulate a Window's Pixmap The behavior for creating a pixmap for a window is moved from Toplevel into a dedicated class WindowPixmap. Scene::Window holds a reference to this class and creates a new WindowPixmap whenever the pixmap needs to be discarded. In addition it also keeps the old WindowPixmap around for the case that creating the new pixmap fails. The compositor can in that case use the previous pixmap which reduces possible flickering. Also this referencing can be used to improve transition effects like the maximize windows effect which would benefit from starting with the old pixmap. For XRender and OpenGL a dedicated sub-class of the WindowPixmap is created which provides the additional mapping to an XRender picture and OpenGL texture respectively. BUG: 319563 FIXED-IN: 4.11 REVIEW: 110577
2013-05-10 10:07:56 +00:00
return success;
}
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
//****************************************
// SceneOpenGL::EffectFrame
//****************************************
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
GLTexture* SceneOpenGL::EffectFrame::m_unstyledTexture = NULL;
Make EffectFrames work with Nouveau driver. This worksaround a problem with the nouveau driver causing the text frames to be incorrectly rendered. We need to keep the QPixmap around as long as we have a texture created from that texture. This applies for the text and the unstyled effect frame. For the frames generated from Plasma's FrameSvgs it is not required. Addresses freedesktop.org bug 30286 svn path=/trunk/KDE/kdebase/workspace/; revision=1184458
2010-10-10 11:26:00 +00:00
QPixmap* SceneOpenGL::EffectFrame::m_unstyledPixmap = NULL;
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +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::EffectFrame::EffectFrame(EffectFrameImpl* frame, SceneOpenGL *scene)
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
: Scene::EffectFrame(frame)
, m_texture(NULL)
, m_textTexture(NULL)
, m_oldTextTexture(NULL)
, m_textPixmap(NULL)
, m_iconTexture(NULL)
, m_oldIconTexture(NULL)
, m_selectionTexture(NULL)
, m_unstyledVBO(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
, m_scene(scene)
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
if (m_effectFrame->style() == EffectFrameUnstyled && !m_unstyledTexture) {
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
updateUnstyledTexture();
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
SceneOpenGL::EffectFrame::~EffectFrame()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
delete m_texture;
delete m_textTexture;
Make EffectFrames work with Nouveau driver. This worksaround a problem with the nouveau driver causing the text frames to be incorrectly rendered. We need to keep the QPixmap around as long as we have a texture created from that texture. This applies for the text and the unstyled effect frame. For the frames generated from Plasma's FrameSvgs it is not required. Addresses freedesktop.org bug 30286 svn path=/trunk/KDE/kdebase/workspace/; revision=1184458
2010-10-10 11:26:00 +00:00
delete m_textPixmap;
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
delete m_oldTextTexture;
Cache the icon texture/picture in EffectFrame and use texture from pixmap to load the data in OpenGL mode. Yeah for less pixmap to image to gltexture conversations. Some effects (boxswitch and flipswitch) still need to be changed to not set the icon in each frame. svn path=/trunk/KDE/kdebase/workspace/; revision=1152367
2010-07-20 21:11:03 +00:00
delete m_iconTexture;
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
delete m_oldIconTexture;
Use the normal Plasma selection to highlight the selected window in boxswitch. So it is more consistent (in KDE newspeak "elegant") with other selections and as a plus we get rid of all the custom rendering code in boxswitch. svn path=/trunk/KDE/kdebase/workspace/; revision=1155051
2010-07-26 20:00:04 +00:00
delete m_selectionTexture;
Use a VBO for rendering an unstyled effect frame. svn path=/trunk/KDE/kdebase/workspace/; revision=1153932
2010-07-24 08:04:17 +00:00
delete m_unstyledVBO;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
void SceneOpenGL::EffectFrame::free()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Perform glFlush before deleting the EffectFrame's pixmaps On NVIDIA it is possible that the actual rendering gets delayed to after the deletion of the pixmap during the end of fullscreen effects. This was causing freezes. By using glFlush before deleting the pixmaps we can ensure that the pixmap is not needed anymore after the pixmaps are deleted. BUG: 261323 FIXED-IN: 4.6.3
2011-04-24 18:20:01 +00:00
glFlush();
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
delete m_texture;
m_texture = NULL;
delete m_textTexture;
m_textTexture = NULL;
Make EffectFrames work with Nouveau driver. This worksaround a problem with the nouveau driver causing the text frames to be incorrectly rendered. We need to keep the QPixmap around as long as we have a texture created from that texture. This applies for the text and the unstyled effect frame. For the frames generated from Plasma's FrameSvgs it is not required. Addresses freedesktop.org bug 30286 svn path=/trunk/KDE/kdebase/workspace/; revision=1184458
2010-10-10 11:26:00 +00:00
delete m_textPixmap;
m_textPixmap = NULL;
Cache the icon texture/picture in EffectFrame and use texture from pixmap to load the data in OpenGL mode. Yeah for less pixmap to image to gltexture conversations. Some effects (boxswitch and flipswitch) still need to be changed to not set the icon in each frame. svn path=/trunk/KDE/kdebase/workspace/; revision=1152367
2010-07-20 21:11:03 +00:00
delete m_iconTexture;
m_iconTexture = NULL;
Use the normal Plasma selection to highlight the selected window in boxswitch. So it is more consistent (in KDE newspeak "elegant") with other selections and as a plus we get rid of all the custom rendering code in boxswitch. svn path=/trunk/KDE/kdebase/workspace/; revision=1155051
2010-07-26 20:00:04 +00:00
delete m_selectionTexture;
m_selectionTexture = NULL;
Use a VBO for rendering an unstyled effect frame. svn path=/trunk/KDE/kdebase/workspace/; revision=1153932
2010-07-24 08:04:17 +00:00
delete m_unstyledVBO;
m_unstyledVBO = NULL;
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
delete m_oldIconTexture;
m_oldIconTexture = NULL;
delete m_oldTextTexture;
m_oldTextTexture = NULL;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Cache the icon texture/picture in EffectFrame and use texture from pixmap to load the data in OpenGL mode. Yeah for less pixmap to image to gltexture conversations. Some effects (boxswitch and flipswitch) still need to be changed to not set the icon in each frame. svn path=/trunk/KDE/kdebase/workspace/; revision=1152367
2010-07-20 21:11:03 +00:00
void SceneOpenGL::EffectFrame::freeIconFrame()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Cache the icon texture/picture in EffectFrame and use texture from pixmap to load the data in OpenGL mode. Yeah for less pixmap to image to gltexture conversations. Some effects (boxswitch and flipswitch) still need to be changed to not set the icon in each frame. svn path=/trunk/KDE/kdebase/workspace/; revision=1152367
2010-07-20 21:11:03 +00:00
delete m_iconTexture;
m_iconTexture = NULL;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
void SceneOpenGL::EffectFrame::freeTextFrame()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
delete m_textTexture;
m_textTexture = NULL;
Make EffectFrames work with Nouveau driver. This worksaround a problem with the nouveau driver causing the text frames to be incorrectly rendered. We need to keep the QPixmap around as long as we have a texture created from that texture. This applies for the text and the unstyled effect frame. For the frames generated from Plasma's FrameSvgs it is not required. Addresses freedesktop.org bug 30286 svn path=/trunk/KDE/kdebase/workspace/; revision=1184458
2010-10-10 11:26:00 +00:00
delete m_textPixmap;
m_textPixmap = NULL;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
Use the normal Plasma selection to highlight the selected window in boxswitch. So it is more consistent (in KDE newspeak "elegant") with other selections and as a plus we get rid of all the custom rendering code in boxswitch. svn path=/trunk/KDE/kdebase/workspace/; revision=1155051
2010-07-26 20:00:04 +00:00
void SceneOpenGL::EffectFrame::freeSelection()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Use the normal Plasma selection to highlight the selected window in boxswitch. So it is more consistent (in KDE newspeak "elegant") with other selections and as a plus we get rid of all the custom rendering code in boxswitch. svn path=/trunk/KDE/kdebase/workspace/; revision=1155051
2010-07-26 20:00:04 +00:00
delete m_selectionTexture;
m_selectionTexture = NULL;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Use the normal Plasma selection to highlight the selected window in boxswitch. So it is more consistent (in KDE newspeak "elegant") with other selections and as a plus we get rid of all the custom rendering code in boxswitch. svn path=/trunk/KDE/kdebase/workspace/; revision=1155051
2010-07-26 20:00:04 +00:00
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
void SceneOpenGL::EffectFrame::crossFadeIcon()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
delete m_oldIconTexture;
m_oldIconTexture = m_iconTexture;
m_iconTexture = NULL;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
void SceneOpenGL::EffectFrame::crossFadeText()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
delete m_oldTextTexture;
m_oldTextTexture = m_textTexture;
m_textTexture = NULL;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
void SceneOpenGL::EffectFrame::render(QRegion region, double opacity, double frameOpacity)
{
if (m_effectFrame->geometry().isEmpty())
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
return; // Nothing to display
region = infiniteRegion(); // TODO: Old region doesn't seem to work with OpenGL
Pass EffectFrame through all effects, so that they can do something with the frame. E.g. set a shader to invert it. CCBUG: 241389 svn path=/trunk/KDE/kdebase/workspace/; revision=1154071
2010-07-24 16:29:16 +00:00
GLShader* shader = m_effectFrame->shader();
Core profile compatible basic scene rendering. Adds a shader to render an untransformed scene. renderGLGeometry is not used any more and replaced by generated triangles stored in a GLVertexBuffer. The GLVertexBuffer has a new attribute to decide whether a core profile compatible rendering has to be performed. Currently windows and EffectFrames can make use of the new shader. The shader contains a debug mode which colours all rendered fragments in green. It is currently enabled in scene_opengl. Rendering transformed geometries (without shader) is currently broken.
2010-11-14 19:49:00 +00:00
bool sceneShader = false;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (!shader && ShaderManager::instance()->isValid()) {
Scene uses ShaderManager
2010-12-11 09:57:29 +00:00
shader = ShaderManager::instance()->pushShader(ShaderManager::SimpleShader);
Core profile compatible basic scene rendering. Adds a shader to render an untransformed scene. renderGLGeometry is not used any more and replaced by generated triangles stored in a GLVertexBuffer. The GLVertexBuffer has a new attribute to decide whether a core profile compatible rendering has to be performed. Currently windows and EffectFrames can make use of the new shader. The shader contains a debug mode which colours all rendered fragments in green. It is currently enabled in scene_opengl. Rendering transformed geometries (without shader) is currently broken.
2010-11-14 19:49:00 +00:00
sceneShader = true;
Better support custom shaders.
2011-01-06 18:55:26 +00:00
} else if (shader) {
ShaderManager::instance()->pushShader(shader);
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (shader) {
if (sceneShader)
kwin: Use the new setUniform() overloads in kwin core
2011-02-10 18:37:51 +00:00
shader->setUniform(GLShader::Offset, QVector2D(0, 0));
Pass EffectFrame through all effects, so that they can do something with the frame. E.g. set a shader to invert it. CCBUG: 241389 svn path=/trunk/KDE/kdebase/workspace/; revision=1154071
2010-07-24 16:29:16 +00:00
kwin: Replace brightness and opacity with a modulation constant This makes it possible to adjust both brightness and opacity at the same time with one multiplication in the fragment shader.
2011-02-12 00:36:21 +00:00
shader->setUniform(GLShader::ModulationConstant, QVector4D(1.0, 1.0, 1.0, 1.0));
kwin: Use the new setUniform() overloads in kwin core
2011-02-10 18:37:51 +00:00
shader->setUniform(GLShader::Saturation, 1.0f);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Pass EffectFrame through all effects, so that they can do something with the frame. E.g. set a shader to invert it. CCBUG: 241389 svn path=/trunk/KDE/kdebase/workspace/; revision=1154071
2010-07-24 16:29:16 +00:00
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
Introduce a build option KWIN_BUILD_OPENGL_1_COMPOSITING If the build option is enabled KWIN_HAVE_OPENGL_1 is passed as a compile flag when build against OpenGL. This compile flag is meant to replace the KWIN_HAVE_OPENGLES. So far code has been ifdefed for special behavior of OpenGL ES 2.0 and to remove fixed functionality calls which are not available in OpenGL ES 2.0. With this build flag the fixed functionality calls which are only used in the OpenGL1 Compositor can be removed and keeping the KWIN_HAVE_OPENGLES for the real differences between OpenGL 2.x and OpenGL ES 2.0. E.g. a call like glColor4f should be in an glColor4f(1.0, 1.0, 1.0, 1.0); while a call like glPolygonMode should be in an glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); Building for OpenGL ES 2.0 of course implies that KWIN_HAVE_OPENGL_1 is not defined.
2012-10-05 08:45:10 +00:00
#ifdef KWIN_HAVE_OPENGL_1
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (!shader)
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
Scene OpenGL compiles with ES It's mostly just ifdef away everything that cannot work. Needs to be split into a scene_xgl and scene_egl.
2010-11-20 12:27:47 +00:00
#endif
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
// Render the actual frame
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (m_effectFrame->style() == EffectFrameUnstyled) {
if (!m_unstyledVBO) {
m_unstyledVBO = new GLVertexBuffer(GLVertexBuffer::Static);
avoid recreating effectframes/textures on setPosition; correct position after setAlignment svn path=/trunk/KDE/kdebase/workspace/; revision=1203489
2010-12-04 10:01:57 +00:00
QRect area = m_effectFrame->geometry();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
area.moveTo(0, 0);
area.adjust(-5, -5, 5, 5);
Use a VBO for rendering an unstyled effect frame. svn path=/trunk/KDE/kdebase/workspace/; revision=1153932
2010-07-24 08:04:17 +00:00
const int roundness = 5;
QVector<float> verts, texCoords;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
verts.reserve(84);
texCoords.reserve(84);
Use a VBO for rendering an unstyled effect frame. svn path=/trunk/KDE/kdebase/workspace/; revision=1153932
2010-07-24 08:04:17 +00:00
// top left
verts << area.left() << area.top();
texCoords << 0.0f << 0.0f;
verts << area.left() << area.top() + roundness;
texCoords << 0.0f << 0.5f;
verts << area.left() + roundness << area.top();
texCoords << 0.5f << 0.0f;
verts << area.left() + roundness << area.top() + roundness;
texCoords << 0.5f << 0.5f;
verts << area.left() << area.top() + roundness;
texCoords << 0.0f << 0.5f;
verts << area.left() + roundness << area.top();
texCoords << 0.5f << 0.0f;
// top
verts << area.left() + roundness << area.top();
texCoords << 0.5f << 0.0f;
verts << area.left() + roundness << area.top() + roundness;
texCoords << 0.5f << 0.5f;
verts << area.right() - roundness << area.top();
texCoords << 0.5f << 0.0f;
verts << area.left() + roundness << area.top() + roundness;
texCoords << 0.5f << 0.5f;
verts << area.right() - roundness << area.top() + roundness;
texCoords << 0.5f << 0.5f;
verts << area.right() - roundness << area.top();
texCoords << 0.5f << 0.0f;
// top right
verts << area.right() - roundness << area.top();
texCoords << 0.5f << 0.0f;
verts << area.right() - roundness << area.top() + roundness;
texCoords << 0.5f << 0.5f;
verts << area.right() << area.top();
texCoords << 1.0f << 0.0f;
verts << area.right() - roundness << area.top() + roundness;
texCoords << 0.5f << 0.5f;
verts << area.right() << area.top() + roundness;
texCoords << 1.0f << 0.5f;
verts << area.right() << area.top();
texCoords << 1.0f << 0.0f;
// bottom left
verts << area.left() << area.bottom() - roundness;
texCoords << 0.0f << 0.5f;
verts << area.left() << area.bottom();
texCoords << 0.0f << 1.0f;
verts << area.left() + roundness << area.bottom() - roundness;
texCoords << 0.5f << 0.5f;
verts << area.left() + roundness << area.bottom();
texCoords << 0.5f << 1.0f;
verts << area.left() << area.bottom();
texCoords << 0.0f << 1.0f;
verts << area.left() + roundness << area.bottom() - roundness;
texCoords << 0.5f << 0.5f;
// bottom
verts << area.left() + roundness << area.bottom() - roundness;
texCoords << 0.5f << 0.5f;
verts << area.left() + roundness << area.bottom();
texCoords << 0.5f << 1.0f;
verts << area.right() - roundness << area.bottom() - roundness;
texCoords << 0.5f << 0.5f;
verts << area.left() + roundness << area.bottom();
texCoords << 0.5f << 1.0f;
verts << area.right() - roundness << area.bottom();
texCoords << 0.5f << 1.0f;
verts << area.right() - roundness << area.bottom() - roundness;
texCoords << 0.5f << 0.5f;
// bottom right
verts << area.right() - roundness << area.bottom() - roundness;
texCoords << 0.5f << 0.5f;
verts << area.right() - roundness << area.bottom();
texCoords << 0.5f << 1.0f;
verts << area.right() << area.bottom() - roundness;
texCoords << 1.0f << 0.5f;
verts << area.right() - roundness << area.bottom();
texCoords << 0.5f << 1.0f;
verts << area.right() << area.bottom();
texCoords << 1.0f << 1.0f;
verts << area.right() << area.bottom() - roundness;
texCoords << 1.0f << 0.5f;
// center
verts << area.left() << area.top() + roundness;
texCoords << 0.0f << 0.5f;
verts << area.left() << area.bottom() - roundness;
texCoords << 0.0f << 0.5f;
verts << area.right() << area.top() + roundness;
texCoords << 1.0f << 0.5f;
verts << area.left() << area.bottom() - roundness;
texCoords << 0.0f << 0.5f;
verts << area.right() << area.bottom() - roundness;
texCoords << 1.0f << 0.5f;
verts << area.right() << area.top() + roundness;
texCoords << 1.0f << 0.5f;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
m_unstyledVBO->setData(verts.count() / 2, 2, verts.data(), texCoords.data());
}
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
kwin: Replace brightness and opacity with a modulation constant This makes it possible to adjust both brightness and opacity at the same time with one multiplication in the fragment shader.
2011-02-12 00:36:21 +00:00
if (shader) {
const float a = opacity * frameOpacity;
shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
}
Introduce a build option KWIN_BUILD_OPENGL_1_COMPOSITING If the build option is enabled KWIN_HAVE_OPENGL_1 is passed as a compile flag when build against OpenGL. This compile flag is meant to replace the KWIN_HAVE_OPENGLES. So far code has been ifdefed for special behavior of OpenGL ES 2.0 and to remove fixed functionality calls which are not available in OpenGL ES 2.0. With this build flag the fixed functionality calls which are only used in the OpenGL1 Compositor can be removed and keeping the KWIN_HAVE_OPENGLES for the real differences between OpenGL 2.x and OpenGL ES 2.0. E.g. a call like glColor4f should be in an glColor4f(1.0, 1.0, 1.0, 1.0); while a call like glPolygonMode should be in an glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); Building for OpenGL ES 2.0 of course implies that KWIN_HAVE_OPENGL_1 is not defined.
2012-10-05 08:45:10 +00:00
#ifdef KWIN_HAVE_OPENGL_1
Pass EffectFrame through all effects, so that they can do something with the frame. E.g. set a shader to invert it. CCBUG: 241389 svn path=/trunk/KDE/kdebase/workspace/; revision=1154071
2010-07-24 16:29:16 +00:00
else
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glColor4f(0.0, 0.0, 0.0, opacity * frameOpacity);
Scene OpenGL compiles with ES It's mostly just ifdef away everything that cannot work. Needs to be split into a scene_xgl and scene_egl.
2010-11-20 12:27:47 +00:00
#endif
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
m_unstyledTexture->bind();
avoid recreating effectframes/textures on setPosition; correct position after setAlignment svn path=/trunk/KDE/kdebase/workspace/; revision=1203489
2010-12-04 10:01:57 +00:00
const QPoint pt = m_effectFrame->geometry().topLeft();
Core profile compatible basic scene rendering. Adds a shader to render an untransformed scene. renderGLGeometry is not used any more and replaced by generated triangles stored in a GLVertexBuffer. The GLVertexBuffer has a new attribute to decide whether a core profile compatible rendering has to be performed. Currently windows and EffectFrames can make use of the new shader. The shader contains a debug mode which colours all rendered fragments in green. It is currently enabled in scene_opengl. Rendering transformed geometries (without shader) is currently broken.
2010-11-14 19:49:00 +00:00
if (sceneShader) {
kwin: Use the new setUniform() overloads in kwin core
2011-02-10 18:37:51 +00:00
shader->setUniform(GLShader::Offset, QVector2D(pt.x(), pt.y()));
Core profile compatible basic scene rendering. Adds a shader to render an untransformed scene. renderGLGeometry is not used any more and replaced by generated triangles stored in a GLVertexBuffer. The GLVertexBuffer has a new attribute to decide whether a core profile compatible rendering has to be performed. Currently windows and EffectFrames can make use of the new shader. The shader contains a debug mode which colours all rendered fragments in green. It is currently enabled in scene_opengl. Rendering transformed geometries (without shader) is currently broken.
2010-11-14 19:49:00 +00:00
} else {
Better support custom shaders.
2011-01-06 18:55:26 +00:00
QMatrix4x4 translation;
translation.translate(pt.x(), pt.y());
if (shader) {
kwin: Use the new setUniform() overloads in kwin core
2011-02-10 18:37:51 +00:00
shader->setUniform(GLShader::WindowTransformation, translation);
Better support custom shaders.
2011-01-06 18:55:26 +00:00
} else {
pushMatrix(translation);
}
Core profile compatible basic scene rendering. Adds a shader to render an untransformed scene. renderGLGeometry is not used any more and replaced by generated triangles stored in a GLVertexBuffer. The GLVertexBuffer has a new attribute to decide whether a core profile compatible rendering has to be performed. Currently windows and EffectFrames can make use of the new shader. The shader contains a debug mode which colours all rendered fragments in green. It is currently enabled in scene_opengl. Rendering transformed geometries (without shader) is currently broken.
2010-11-14 19:49:00 +00:00
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
m_unstyledVBO->render(region, GL_TRIANGLES);
Core profile compatible basic scene rendering. Adds a shader to render an untransformed scene. renderGLGeometry is not used any more and replaced by generated triangles stored in a GLVertexBuffer. The GLVertexBuffer has a new attribute to decide whether a core profile compatible rendering has to be performed. Currently windows and EffectFrames can make use of the new shader. The shader contains a debug mode which colours all rendered fragments in green. It is currently enabled in scene_opengl. Rendering transformed geometries (without shader) is currently broken.
2010-11-14 19:49:00 +00:00
if (!sceneShader) {
Better support custom shaders.
2011-01-06 18:55:26 +00:00
if (shader) {
kwin: Use the new setUniform() overloads in kwin core
2011-02-10 18:37:51 +00:00
shader->setUniform(GLShader::WindowTransformation, QMatrix4x4());
Better support custom shaders.
2011-01-06 18:55:26 +00:00
} else {
popMatrix();
}
Core profile compatible basic scene rendering. Adds a shader to render an untransformed scene. renderGLGeometry is not used any more and replaced by generated triangles stored in a GLVertexBuffer. The GLVertexBuffer has a new attribute to decide whether a core profile compatible rendering has to be performed. Currently windows and EffectFrames can make use of the new shader. The shader contains a debug mode which colours all rendered fragments in green. It is currently enabled in scene_opengl. Rendering transformed geometries (without shader) is currently broken.
2010-11-14 19:49:00 +00:00
}
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
m_unstyledTexture->unbind();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
} else if (m_effectFrame->style() == EffectFrameStyled) {
if (!m_texture) // Lazy creation
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
updateTexture();
kwin: Replace brightness and opacity with a modulation constant This makes it possible to adjust both brightness and opacity at the same time with one multiplication in the fragment shader.
2011-02-12 00:36:21 +00:00
if (shader) {
const float a = opacity * frameOpacity;
shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
}
Introduce a build option KWIN_BUILD_OPENGL_1_COMPOSITING If the build option is enabled KWIN_HAVE_OPENGL_1 is passed as a compile flag when build against OpenGL. This compile flag is meant to replace the KWIN_HAVE_OPENGLES. So far code has been ifdefed for special behavior of OpenGL ES 2.0 and to remove fixed functionality calls which are not available in OpenGL ES 2.0. With this build flag the fixed functionality calls which are only used in the OpenGL1 Compositor can be removed and keeping the KWIN_HAVE_OPENGLES for the real differences between OpenGL 2.x and OpenGL ES 2.0. E.g. a call like glColor4f should be in an glColor4f(1.0, 1.0, 1.0, 1.0); while a call like glPolygonMode should be in an glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); Building for OpenGL ES 2.0 of course implies that KWIN_HAVE_OPENGL_1 is not defined.
2012-10-05 08:45:10 +00:00
#ifdef KWIN_HAVE_OPENGL_1
Pass EffectFrame through all effects, so that they can do something with the frame. E.g. set a shader to invert it. CCBUG: 241389 svn path=/trunk/KDE/kdebase/workspace/; revision=1154071
2010-07-24 16:29:16 +00:00
else
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glColor4f(1.0, 1.0, 1.0, opacity * frameOpacity);
Scene OpenGL compiles with ES It's mostly just ifdef away everything that cannot work. Needs to be split into a scene_xgl and scene_egl.
2010-11-20 12:27:47 +00:00
#endif
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
m_texture->bind();
qreal left, top, right, bottom;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
m_effectFrame->frame().getMargins(left, top, right, bottom); // m_geometry is the inner geometry
m_texture->render(region, m_effectFrame->geometry().adjusted(-left, -top, right, bottom));
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
m_texture->unbind();
Use the normal Plasma selection to highlight the selected window in boxswitch. So it is more consistent (in KDE newspeak "elegant") with other selections and as a plus we get rid of all the custom rendering code in boxswitch. svn path=/trunk/KDE/kdebase/workspace/; revision=1155051
2010-07-26 20:00:04 +00:00
Remove binding of selection to styled EffectFrame This allows to just set the selection on a None EffectFrame so that only the selection is rendered without blurring the background and so on.
2011-04-28 11:41:11 +00:00
}
if (!m_effectFrame->selection().isNull()) {
if (!m_selectionTexture) { // Lazy creation
QPixmap pixmap = m_effectFrame->selectionFrame().framePixmap();
avoid calling QPixmap::paintEngine() in scene rendering by checking the graphicssystem at startup also avoid pixmap and memory leaking on the xrender backend, validate some pointers on deletion in SceneOpnGL and avoid attempts to render ::isNull pixmaps
2011-06-11 12:48:16 +00:00
if (!pixmap.isNull())
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_selectionTexture = m_scene->createTexture(pixmap);
Remove binding of selection to styled EffectFrame This allows to just set the selection on a None EffectFrame so that only the selection is rendered without blurring the background and so on.
2011-04-28 11:41:11 +00:00
}
avoid calling QPixmap::paintEngine() in scene rendering by checking the graphicssystem at startup also avoid pixmap and memory leaking on the xrender backend, validate some pointers on deletion in SceneOpnGL and avoid attempts to render ::isNull pixmaps
2011-06-11 12:48:16 +00:00
if (m_selectionTexture) {
if (shader) {
const float a = opacity * frameOpacity;
shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
}
Introduce a build option KWIN_BUILD_OPENGL_1_COMPOSITING If the build option is enabled KWIN_HAVE_OPENGL_1 is passed as a compile flag when build against OpenGL. This compile flag is meant to replace the KWIN_HAVE_OPENGLES. So far code has been ifdefed for special behavior of OpenGL ES 2.0 and to remove fixed functionality calls which are not available in OpenGL ES 2.0. With this build flag the fixed functionality calls which are only used in the OpenGL1 Compositor can be removed and keeping the KWIN_HAVE_OPENGLES for the real differences between OpenGL 2.x and OpenGL ES 2.0. E.g. a call like glColor4f should be in an glColor4f(1.0, 1.0, 1.0, 1.0); while a call like glPolygonMode should be in an glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); Building for OpenGL ES 2.0 of course implies that KWIN_HAVE_OPENGL_1 is not defined.
2012-10-05 08:45:10 +00:00
#ifdef KWIN_HAVE_OPENGL_1
avoid calling QPixmap::paintEngine() in scene rendering by checking the graphicssystem at startup also avoid pixmap and memory leaking on the xrender backend, validate some pointers on deletion in SceneOpnGL and avoid attempts to render ::isNull pixmaps
2011-06-11 12:48:16 +00:00
else
glColor4f(1.0, 1.0, 1.0, opacity * frameOpacity);
#endif
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
m_selectionTexture->bind();
m_selectionTexture->render(region, m_effectFrame->selection());
m_selectionTexture->unbind();
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
// Render icon
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (!m_effectFrame->icon().isNull() && !m_effectFrame->iconSize().isEmpty()) {
QPoint topLeft(m_effectFrame->geometry().x(),
m_effectFrame->geometry().center().y() - m_effectFrame->iconSize().height() / 2);
if (m_effectFrame->isCrossFade() && m_oldIconTexture) {
kwin: Replace brightness and opacity with a modulation constant This makes it possible to adjust both brightness and opacity at the same time with one multiplication in the fragment shader.
2011-02-12 00:36:21 +00:00
if (shader) {
const float a = opacity * (1.0 - m_effectFrame->crossFadeProgress());
shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
}
Introduce a build option KWIN_BUILD_OPENGL_1_COMPOSITING If the build option is enabled KWIN_HAVE_OPENGL_1 is passed as a compile flag when build against OpenGL. This compile flag is meant to replace the KWIN_HAVE_OPENGLES. So far code has been ifdefed for special behavior of OpenGL ES 2.0 and to remove fixed functionality calls which are not available in OpenGL ES 2.0. With this build flag the fixed functionality calls which are only used in the OpenGL1 Compositor can be removed and keeping the KWIN_HAVE_OPENGLES for the real differences between OpenGL 2.x and OpenGL ES 2.0. E.g. a call like glColor4f should be in an glColor4f(1.0, 1.0, 1.0, 1.0); while a call like glPolygonMode should be in an glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); Building for OpenGL ES 2.0 of course implies that KWIN_HAVE_OPENGL_1 is not defined.
2012-10-05 08:45:10 +00:00
#ifdef KWIN_HAVE_OPENGL_1
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
else
kwin: Use the new setUniform() overloads in kwin core
2011-02-10 18:37:51 +00:00
glColor4f(1.0, 1.0, 1.0, opacity * (1.0 - m_effectFrame->crossFadeProgress()));
Scene OpenGL compiles with ES It's mostly just ifdef away everything that cannot work. Needs to be split into a scene_xgl and scene_egl.
2010-11-20 12:27:47 +00:00
#endif
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
m_oldIconTexture->bind();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
m_oldIconTexture->render(region, QRect(topLeft, m_effectFrame->iconSize()));
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
m_oldIconTexture->unbind();
kwin: Replace brightness and opacity with a modulation constant This makes it possible to adjust both brightness and opacity at the same time with one multiplication in the fragment shader.
2011-02-12 00:36:21 +00:00
if (shader) {
const float a = opacity * m_effectFrame->crossFadeProgress();
shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
}
Introduce a build option KWIN_BUILD_OPENGL_1_COMPOSITING If the build option is enabled KWIN_HAVE_OPENGL_1 is passed as a compile flag when build against OpenGL. This compile flag is meant to replace the KWIN_HAVE_OPENGLES. So far code has been ifdefed for special behavior of OpenGL ES 2.0 and to remove fixed functionality calls which are not available in OpenGL ES 2.0. With this build flag the fixed functionality calls which are only used in the OpenGL1 Compositor can be removed and keeping the KWIN_HAVE_OPENGLES for the real differences between OpenGL 2.x and OpenGL ES 2.0. E.g. a call like glColor4f should be in an glColor4f(1.0, 1.0, 1.0, 1.0); while a call like glPolygonMode should be in an glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); Building for OpenGL ES 2.0 of course implies that KWIN_HAVE_OPENGL_1 is not defined.
2012-10-05 08:45:10 +00:00
#ifdef KWIN_HAVE_OPENGL_1
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
else
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glColor4f(1.0, 1.0, 1.0, opacity * m_effectFrame->crossFadeProgress());
Scene OpenGL compiles with ES It's mostly just ifdef away everything that cannot work. Needs to be split into a scene_xgl and scene_egl.
2010-11-20 12:27:47 +00:00
#endif
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
} else {
kwin: Replace brightness and opacity with a modulation constant This makes it possible to adjust both brightness and opacity at the same time with one multiplication in the fragment shader.
2011-02-12 00:36:21 +00:00
if (shader) {
const QVector4D constant(opacity, opacity, opacity, opacity);
shader->setUniform(GLShader::ModulationConstant, constant);
}
Introduce a build option KWIN_BUILD_OPENGL_1_COMPOSITING If the build option is enabled KWIN_HAVE_OPENGL_1 is passed as a compile flag when build against OpenGL. This compile flag is meant to replace the KWIN_HAVE_OPENGLES. So far code has been ifdefed for special behavior of OpenGL ES 2.0 and to remove fixed functionality calls which are not available in OpenGL ES 2.0. With this build flag the fixed functionality calls which are only used in the OpenGL1 Compositor can be removed and keeping the KWIN_HAVE_OPENGLES for the real differences between OpenGL 2.x and OpenGL ES 2.0. E.g. a call like glColor4f should be in an glColor4f(1.0, 1.0, 1.0, 1.0); while a call like glPolygonMode should be in an glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); Building for OpenGL ES 2.0 of course implies that KWIN_HAVE_OPENGL_1 is not defined.
2012-10-05 08:45:10 +00:00
#ifdef KWIN_HAVE_OPENGL_1
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
else
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glColor4f(1.0, 1.0, 1.0, opacity);
Scene OpenGL compiles with ES It's mostly just ifdef away everything that cannot work. Needs to be split into a scene_xgl and scene_egl.
2010-11-20 12:27:47 +00:00
#endif
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (!m_iconTexture) { // lazy creation
[kwin] Use a QIcon in Client for the icons instead of Pixmaps Client used to have dedicated methods for different icon sizes instead of combining all pixmaps into one QIcon. This resulted in various parts of KWin having different access to the icons: * effects only got one pixmap of size 32x32 * decorations only got the 16x16 and 32x32 pixmaps combined into a QIcon * tabbox could request all icon sizes, but only as pixmap Now all sizes are available in one QIcon allowing to easily access the best fitting icon in a given UI.
2013-12-06 13:41:23 +00:00
m_iconTexture = m_scene->createTexture(m_effectFrame->icon().pixmap(m_effectFrame->iconSize()));
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Cache the icon texture/picture in EffectFrame and use texture from pixmap to load the data in OpenGL mode. Yeah for less pixmap to image to gltexture conversations. Some effects (boxswitch and flipswitch) still need to be changed to not set the icon in each frame. svn path=/trunk/KDE/kdebase/workspace/; revision=1152367
2010-07-20 21:11:03 +00:00
m_iconTexture->bind();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
m_iconTexture->render(region, QRect(topLeft, m_effectFrame->iconSize()));
Cache the icon texture/picture in EffectFrame and use texture from pixmap to load the data in OpenGL mode. Yeah for less pixmap to image to gltexture conversations. Some effects (boxswitch and flipswitch) still need to be changed to not set the icon in each frame. svn path=/trunk/KDE/kdebase/workspace/; revision=1152367
2010-07-20 21:11:03 +00:00
m_iconTexture->unbind();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
// Render text
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (!m_effectFrame->text().isEmpty()) {
if (m_effectFrame->isCrossFade() && m_oldTextTexture) {
kwin: Replace brightness and opacity with a modulation constant This makes it possible to adjust both brightness and opacity at the same time with one multiplication in the fragment shader.
2011-02-12 00:36:21 +00:00
if (shader) {
const float a = opacity * (1.0 - m_effectFrame->crossFadeProgress());
shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
}
Introduce a build option KWIN_BUILD_OPENGL_1_COMPOSITING If the build option is enabled KWIN_HAVE_OPENGL_1 is passed as a compile flag when build against OpenGL. This compile flag is meant to replace the KWIN_HAVE_OPENGLES. So far code has been ifdefed for special behavior of OpenGL ES 2.0 and to remove fixed functionality calls which are not available in OpenGL ES 2.0. With this build flag the fixed functionality calls which are only used in the OpenGL1 Compositor can be removed and keeping the KWIN_HAVE_OPENGLES for the real differences between OpenGL 2.x and OpenGL ES 2.0. E.g. a call like glColor4f should be in an glColor4f(1.0, 1.0, 1.0, 1.0); while a call like glPolygonMode should be in an glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); Building for OpenGL ES 2.0 of course implies that KWIN_HAVE_OPENGL_1 is not defined.
2012-10-05 08:45:10 +00:00
#ifdef KWIN_HAVE_OPENGL_1
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
else
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glColor4f(1.0, 1.0, 1.0, opacity *(1.0 - m_effectFrame->crossFadeProgress()));
Scene OpenGL compiles with ES It's mostly just ifdef away everything that cannot work. Needs to be split into a scene_xgl and scene_egl.
2010-11-20 12:27:47 +00:00
#endif
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
m_oldTextTexture->bind();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
m_oldTextTexture->render(region, m_effectFrame->geometry());
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
m_oldTextTexture->unbind();
kwin: Replace brightness and opacity with a modulation constant This makes it possible to adjust both brightness and opacity at the same time with one multiplication in the fragment shader.
2011-02-12 00:36:21 +00:00
if (shader) {
const float a = opacity * m_effectFrame->crossFadeProgress();
shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
}
Introduce a build option KWIN_BUILD_OPENGL_1_COMPOSITING If the build option is enabled KWIN_HAVE_OPENGL_1 is passed as a compile flag when build against OpenGL. This compile flag is meant to replace the KWIN_HAVE_OPENGLES. So far code has been ifdefed for special behavior of OpenGL ES 2.0 and to remove fixed functionality calls which are not available in OpenGL ES 2.0. With this build flag the fixed functionality calls which are only used in the OpenGL1 Compositor can be removed and keeping the KWIN_HAVE_OPENGLES for the real differences between OpenGL 2.x and OpenGL ES 2.0. E.g. a call like glColor4f should be in an glColor4f(1.0, 1.0, 1.0, 1.0); while a call like glPolygonMode should be in an glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); Building for OpenGL ES 2.0 of course implies that KWIN_HAVE_OPENGL_1 is not defined.
2012-10-05 08:45:10 +00:00
#ifdef KWIN_HAVE_OPENGL_1
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
else
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glColor4f(1.0, 1.0, 1.0, opacity * m_effectFrame->crossFadeProgress());
Scene OpenGL compiles with ES It's mostly just ifdef away everything that cannot work. Needs to be split into a scene_xgl and scene_egl.
2010-11-20 12:27:47 +00:00
#endif
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
} else {
kwin: Replace brightness and opacity with a modulation constant This makes it possible to adjust both brightness and opacity at the same time with one multiplication in the fragment shader.
2011-02-12 00:36:21 +00:00
if (shader) {
const QVector4D constant(opacity, opacity, opacity, opacity);
shader->setUniform(GLShader::ModulationConstant, constant);
}
Introduce a build option KWIN_BUILD_OPENGL_1_COMPOSITING If the build option is enabled KWIN_HAVE_OPENGL_1 is passed as a compile flag when build against OpenGL. This compile flag is meant to replace the KWIN_HAVE_OPENGLES. So far code has been ifdefed for special behavior of OpenGL ES 2.0 and to remove fixed functionality calls which are not available in OpenGL ES 2.0. With this build flag the fixed functionality calls which are only used in the OpenGL1 Compositor can be removed and keeping the KWIN_HAVE_OPENGLES for the real differences between OpenGL 2.x and OpenGL ES 2.0. E.g. a call like glColor4f should be in an glColor4f(1.0, 1.0, 1.0, 1.0); while a call like glPolygonMode should be in an glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); Building for OpenGL ES 2.0 of course implies that KWIN_HAVE_OPENGL_1 is not defined.
2012-10-05 08:45:10 +00:00
#ifdef KWIN_HAVE_OPENGL_1
Add cross fade support for text and icon to EffectFrame. This allows an effect to fade between old and new text/icon. As an example it's added to CoverSwitch. Currently only supported in OpenGL. XRender might be added, but I'm missing an idea for an effect to add it. Most effects using EffectFrame require OpenGL anyway. svn path=/trunk/KDE/kdebase/workspace/; revision=1160252
2010-08-07 14:08:34 +00:00
else
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glColor4f(1.0, 1.0, 1.0, opacity);
Scene OpenGL compiles with ES It's mostly just ifdef away everything that cannot work. Needs to be split into a scene_xgl and scene_egl.
2010-11-20 12:27:47 +00:00
#endif
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
if (!m_textTexture) // Lazy creation
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
updateTextTexture();
m_textTexture->bind();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
m_textTexture->render(region, m_effectFrame->geometry());
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
m_textTexture->unbind();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
Scene uses ShaderManager
2010-12-11 09:57:29 +00:00
if (shader) {
ShaderManager::instance()->popShader();
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
glDisable(GL_BLEND);
}
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
void SceneOpenGL::EffectFrame::updateTexture()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
delete m_texture;
avoid calling QPixmap::paintEngine() in scene rendering by checking the graphicssystem at startup also avoid pixmap and memory leaking on the xrender backend, validate some pointers on deletion in SceneOpnGL and avoid attempts to render ::isNull pixmaps
2011-06-11 12:48:16 +00:00
m_texture = 0L;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (m_effectFrame->style() == EffectFrameStyled) {
Use Texture From Pixmap for the styled EffectFrame svn path=/trunk/KDE/kdebase/workspace/; revision=1155056
2010-07-26 20:16:54 +00:00
QPixmap pixmap = m_effectFrame->frame().framePixmap();
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_texture = m_scene->createTexture(pixmap);
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
void SceneOpenGL::EffectFrame::updateTextTexture()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
delete m_textTexture;
avoid calling QPixmap::paintEngine() in scene rendering by checking the graphicssystem at startup also avoid pixmap and memory leaking on the xrender backend, validate some pointers on deletion in SceneOpnGL and avoid attempts to render ::isNull pixmaps
2011-06-11 12:48:16 +00:00
m_textTexture = 0L;
Make EffectFrames work with Nouveau driver. This worksaround a problem with the nouveau driver causing the text frames to be incorrectly rendered. We need to keep the QPixmap around as long as we have a texture created from that texture. This applies for the text and the unstyled effect frame. For the frames generated from Plasma's FrameSvgs it is not required. Addresses freedesktop.org bug 30286 svn path=/trunk/KDE/kdebase/workspace/; revision=1184458
2010-10-10 11:26:00 +00:00
delete m_textPixmap;
avoid calling QPixmap::paintEngine() in scene rendering by checking the graphicssystem at startup also avoid pixmap and memory leaking on the xrender backend, validate some pointers on deletion in SceneOpnGL and avoid attempts to render ::isNull pixmaps
2011-06-11 12:48:16 +00:00
m_textPixmap = 0L;
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (m_effectFrame->text().isEmpty())
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
return;
// Determine position on texture to paint text
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
QRect rect(QPoint(0, 0), m_effectFrame->geometry().size());
if (!m_effectFrame->icon().isNull() && !m_effectFrame->iconSize().isEmpty())
rect.setLeft(m_effectFrame->iconSize().width());
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
// If static size elide text as required
QString text = m_effectFrame->text();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
if (m_effectFrame->isStatic()) {
QFontMetrics metrics(m_effectFrame->font());
text = metrics.elidedText(text, Qt::ElideRight, rect.width());
}
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
m_textPixmap = new QPixmap(m_effectFrame->geometry().size());
m_textPixmap->fill(Qt::transparent);
QPainter p(m_textPixmap);
p.setFont(m_effectFrame->font());
if (m_effectFrame->style() == EffectFrameStyled)
p.setPen(m_effectFrame->styledTextColor());
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
else // TODO: What about no frame? Custom color setting required
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
p.setPen(Qt::white);
p.drawText(rect, m_effectFrame->alignment(), text);
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
p.end();
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_textTexture = m_scene->createTexture(*m_textPixmap);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
void SceneOpenGL::EffectFrame::updateUnstyledTexture()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
delete m_unstyledTexture;
avoid calling QPixmap::paintEngine() in scene rendering by checking the graphicssystem at startup also avoid pixmap and memory leaking on the xrender backend, validate some pointers on deletion in SceneOpnGL and avoid attempts to render ::isNull pixmaps
2011-06-11 12:48:16 +00:00
m_unstyledTexture = 0L;
Make EffectFrames work with Nouveau driver. This worksaround a problem with the nouveau driver causing the text frames to be incorrectly rendered. We need to keep the QPixmap around as long as we have a texture created from that texture. This applies for the text and the unstyled effect frame. For the frames generated from Plasma's FrameSvgs it is not required. Addresses freedesktop.org bug 30286 svn path=/trunk/KDE/kdebase/workspace/; revision=1184458
2010-10-10 11:26:00 +00:00
delete m_unstyledPixmap;
avoid calling QPixmap::paintEngine() in scene rendering by checking the graphicssystem at startup also avoid pixmap and memory leaking on the xrender backend, validate some pointers on deletion in SceneOpnGL and avoid attempts to render ::isNull pixmaps
2011-06-11 12:48:16 +00:00
m_unstyledPixmap = 0L;
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
// Based off circle() from kwinxrenderutils.cpp
#define CS 8
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
m_unstyledPixmap = new QPixmap(2 * CS, 2 * CS);
m_unstyledPixmap->fill(Qt::transparent);
QPainter p(m_unstyledPixmap);
p.setRenderHint(QPainter::Antialiasing);
p.setPen(Qt::NoPen);
p.setBrush(Qt::black);
p.drawEllipse(m_unstyledPixmap->rect());
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
p.end();
#undef CS
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_unstyledTexture = new GLTexture(*m_unstyledPixmap);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
void SceneOpenGL::EffectFrame::cleanup()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
delete m_unstyledTexture;
m_unstyledTexture = NULL;
Make EffectFrames work with Nouveau driver. This worksaround a problem with the nouveau driver causing the text frames to be incorrectly rendered. We need to keep the QPixmap around as long as we have a texture created from that texture. This applies for the text and the unstyled effect frame. For the frames generated from Plasma's FrameSvgs it is not required. Addresses freedesktop.org bug 30286 svn path=/trunk/KDE/kdebase/workspace/; revision=1184458
2010-10-10 11:26:00 +00:00
delete m_unstyledPixmap;
m_unstyledPixmap = NULL;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
//****************************************
// SceneOpenGL::Shadow
//****************************************
SceneOpenGLShadow::SceneOpenGLShadow(Toplevel *toplevel)
: Shadow(toplevel)
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
, m_texture(NULL)
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
{
}
SceneOpenGLShadow::~SceneOpenGLShadow()
{
Better handling for making the compositing OpenGL context current With QtQuick2 it's possible that the scene graph rendering context either lives in an own thread or uses the main GUI thread. In the latter case it's the same thread as our compositing OpenGL context lives in. This means our basic assumption that between two rendering passes the context stays current does not hold. The code already ensured that before we start a rendering pass the context is made current, but there are many more possible cases. If we use OpenGL in areas not triggered by the rendering loop but in response to other events the context needs to be made current. This includes the loading and unloading of effects (some effects use OpenGL in the static effect check, in the ctor and dtor), background loading of texture data, lazy loading after first usage invoked by shortcut, etc. etc. To properly handle these cases new methods are added to EffectsHandler to make the compositing OpenGL context current. These calls delegate down into the scene. On non-OpenGL scenes they are noop, but on OpenGL they go into the backend and make the context current. In addition they ensure that Qt doesn't think that it's QOpenGLContext is current by calling doneCurrent() on the QOpenGLContext::currentContext(). This unfortunately causes an additional call to makeCurrent with a null context, but there is no other way to tell Qt - it doesn't notice when a different context is made current with low level API calls. In the multi-threaded architecture this doesn't matter as ::currentContext() returns null. A short evaluation showed that a transition to QOpenGLContext doesn't seem feasible. Qt only supports either GLX or EGL while KWin supports both and when entering the transition phase for Wayland, it would become extremely tricky if our native platform is X11, but we want a Wayland EGL context. A future solution might be to have a "KWin-QPA plugin" which uses either xcb or Wayland and hides everything from Qt. The API documentation is extended to describe when the effects-framework ensures that an OpenGL context is current. The effects are changed to make the context current in cases where it's not guaranteed. This has been done by looking for creation or deletion of GLTextures and Shaders. If there are other OpenGL usages outside the rendering loop, ctor/dtor this needs to be changed, too.
2013-11-22 14:05:36 +00:00
effects->makeOpenGLContextCurrent();
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
delete m_texture;
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
}
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
void SceneOpenGLShadow::buildQuads()
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
{
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
// prepare window quads
simplify opengl shadow building code REVIEW: 103236 (cherry picked from commit 9ff807b192313c01d2e4d77a2db791bd7b53b680)
2011-11-25 14:03:21 +00:00
m_shadowQuads.clear();
const QSizeF top(shadowPixmap(ShadowElementTop).size());
const QSizeF topRight(shadowPixmap(ShadowElementTopRight).size());
const QSizeF right(shadowPixmap(ShadowElementRight).size());
const QSizeF bottomRight(shadowPixmap(ShadowElementBottomRight).size());
const QSizeF bottom(shadowPixmap(ShadowElementBottom).size());
const QSizeF bottomLeft(shadowPixmap(ShadowElementBottomLeft).size());
const QSizeF left(shadowPixmap(ShadowElementLeft).size());
const QSizeF topLeft(shadowPixmap(ShadowElementTopLeft).size());
if ((left.width() - leftOffset() > topLevel()->width()) ||
(right.width() - rightOffset() > topLevel()->width()) ||
(top.height() - topOffset() > topLevel()->height()) ||
(bottom.height() - bottomOffset() > topLevel()->height())) {
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
// if our shadow is bigger than the window, we don't render the shadow
setShadowRegion(QRegion());
return;
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
}
simplify opengl shadow building code REVIEW: 103236 (cherry picked from commit 9ff807b192313c01d2e4d77a2db791bd7b53b680)
2011-11-25 14:03:21 +00:00
fix NPOT shadows a) fixes the texture offset calculation b) arranges he shadow pixmaps as border in the texture to avoid interpolation issues. BUG: 280116 BUG: 282882 CCBUG: 291161 BUG: 293325 REVIEW: 103888
2012-02-08 18:31:17 +00:00
const QRectF outerRect(QPointF(-leftOffset(), -topOffset()),
QPointF(topLevel()->width() + rightOffset(), topLevel()->height() + bottomOffset()));
simplify opengl shadow building code REVIEW: 103236 (cherry picked from commit 9ff807b192313c01d2e4d77a2db791bd7b53b680)
2011-11-25 14:03:21 +00:00
fix NPOT shadows a) fixes the texture offset calculation b) arranges he shadow pixmaps as border in the texture to avoid interpolation issues. BUG: 280116 BUG: 282882 CCBUG: 291161 BUG: 293325 REVIEW: 103888
2012-02-08 18:31:17 +00:00
const qreal width = topLeft.width() + top.width() + topRight.width();
const qreal height = topLeft.height() + left.height() + bottomLeft.height();
simplify opengl shadow building code REVIEW: 103236 (cherry picked from commit 9ff807b192313c01d2e4d77a2db791bd7b53b680)
2011-11-25 14:03:21 +00:00
qreal tx1(0.0), tx2(0.0), ty1(0.0), ty2(0.0);
tx2 = topLeft.width()/width;
ty2 = topLeft.height()/height;
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
WindowQuad topLeftQuad(WindowQuadShadowTopLeft);
simplify opengl shadow building code REVIEW: 103236 (cherry picked from commit 9ff807b192313c01d2e4d77a2db791bd7b53b680)
2011-11-25 14:03:21 +00:00
topLeftQuad[ 0 ] = WindowVertex(outerRect.x(), outerRect.y(), tx1, ty1);
topLeftQuad[ 1 ] = WindowVertex(outerRect.x() + topLeft.width(), outerRect.y(), tx2, ty1);
topLeftQuad[ 2 ] = WindowVertex(outerRect.x() + topLeft.width(), outerRect.y() + topLeft.height(), tx2, ty2);
topLeftQuad[ 3 ] = WindowVertex(outerRect.x(), outerRect.y() + topLeft.height(), tx1, ty2);
m_shadowQuads.append(topLeftQuad);
fix NPOT shadows a) fixes the texture offset calculation b) arranges he shadow pixmaps as border in the texture to avoid interpolation issues. BUG: 280116 BUG: 282882 CCBUG: 291161 BUG: 293325 REVIEW: 103888
2012-02-08 18:31:17 +00:00
tx1 = tx2;
tx2 = (topLeft.width() + top.width())/width;
ty2 = top.height()/height;
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
WindowQuad topQuad(WindowQuadShadowTop);
simplify opengl shadow building code REVIEW: 103236 (cherry picked from commit 9ff807b192313c01d2e4d77a2db791bd7b53b680)
2011-11-25 14:03:21 +00:00
topQuad[ 0 ] = WindowVertex(outerRect.x() + topLeft.width(), outerRect.y(), tx1, ty1);
topQuad[ 1 ] = WindowVertex(outerRect.right() - topRight.width(), outerRect.y(), tx2, ty1);
topQuad[ 2 ] = WindowVertex(outerRect.right() - topRight.width(), outerRect.y() + top.height(),tx2, ty2);
topQuad[ 3 ] = WindowVertex(outerRect.x() + topLeft.width(), outerRect.y() + top.height(), tx1, ty2);
m_shadowQuads.append(topQuad);
fix NPOT shadows a) fixes the texture offset calculation b) arranges he shadow pixmaps as border in the texture to avoid interpolation issues. BUG: 280116 BUG: 282882 CCBUG: 291161 BUG: 293325 REVIEW: 103888
2012-02-08 18:31:17 +00:00
tx1 = tx2;
tx2 = 1.0;
simplify opengl shadow building code REVIEW: 103236 (cherry picked from commit 9ff807b192313c01d2e4d77a2db791bd7b53b680)
2011-11-25 14:03:21 +00:00
ty2 = topRight.height()/height;
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
WindowQuad topRightQuad(WindowQuadShadowTopRight);
simplify opengl shadow building code REVIEW: 103236 (cherry picked from commit 9ff807b192313c01d2e4d77a2db791bd7b53b680)
2011-11-25 14:03:21 +00:00
topRightQuad[ 0 ] = WindowVertex(outerRect.right() - topRight.width(), outerRect.y(), tx1, ty1);
topRightQuad[ 1 ] = WindowVertex(outerRect.right(), outerRect.y(), tx2, ty1);
topRightQuad[ 2 ] = WindowVertex(outerRect.right(), outerRect.y() + topRight.height(), tx2, ty2);
topRightQuad[ 3 ] = WindowVertex(outerRect.right() - topRight.width(), outerRect.y() + topRight.height(), tx1, ty2);
m_shadowQuads.append(topRightQuad);
fix NPOT shadows a) fixes the texture offset calculation b) arranges he shadow pixmaps as border in the texture to avoid interpolation issues. BUG: 280116 BUG: 282882 CCBUG: 291161 BUG: 293325 REVIEW: 103888
2012-02-08 18:31:17 +00:00
tx1 = (width - right.width())/width;
ty1 = topRight.height()/height;
ty2 = (topRight.height() + right.height())/height;
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
WindowQuad rightQuad(WindowQuadShadowRight);
simplify opengl shadow building code REVIEW: 103236 (cherry picked from commit 9ff807b192313c01d2e4d77a2db791bd7b53b680)
2011-11-25 14:03:21 +00:00
rightQuad[ 0 ] = WindowVertex(outerRect.right() - right.width(), outerRect.y() + topRight.height(), tx1, ty1);
rightQuad[ 1 ] = WindowVertex(outerRect.right(), outerRect.y() + topRight.height(), tx2, ty1);
rightQuad[ 2 ] = WindowVertex(outerRect.right(), outerRect.bottom() - bottomRight.height(), tx2, ty2);
rightQuad[ 3 ] = WindowVertex(outerRect.right() - right.width(), outerRect.bottom() - bottomRight.height(), tx1, ty2);
m_shadowQuads.append(rightQuad);
fix NPOT shadows a) fixes the texture offset calculation b) arranges he shadow pixmaps as border in the texture to avoid interpolation issues. BUG: 280116 BUG: 282882 CCBUG: 291161 BUG: 293325 REVIEW: 103888
2012-02-08 18:31:17 +00:00
tx1 = (width - bottomRight.width())/width;
ty1 = ty2;
ty2 = 1.0;
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
WindowQuad bottomRightQuad(WindowQuadShadowBottomRight);
simplify opengl shadow building code REVIEW: 103236 (cherry picked from commit 9ff807b192313c01d2e4d77a2db791bd7b53b680)
2011-11-25 14:03:21 +00:00
bottomRightQuad[ 0 ] = WindowVertex(outerRect.right() - bottomRight.width(), outerRect.bottom() - bottomRight.height(), tx1, ty1);
bottomRightQuad[ 1 ] = WindowVertex(outerRect.right(), outerRect.bottom() - bottomRight.height(), tx2, ty1);
bottomRightQuad[ 2 ] = WindowVertex(outerRect.right(), outerRect.bottom(), tx2, ty2);
bottomRightQuad[ 3 ] = WindowVertex(outerRect.right() - bottomRight.width(), outerRect.bottom(), tx1, ty2);
m_shadowQuads.append(bottomRightQuad);
fix NPOT shadows a) fixes the texture offset calculation b) arranges he shadow pixmaps as border in the texture to avoid interpolation issues. BUG: 280116 BUG: 282882 CCBUG: 291161 BUG: 293325 REVIEW: 103888
2012-02-08 18:31:17 +00:00
tx2 = tx1;
tx1 = bottomLeft.width()/width;
ty1 = (height - bottom.height())/height;
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
WindowQuad bottomQuad(WindowQuadShadowBottom);
simplify opengl shadow building code REVIEW: 103236 (cherry picked from commit 9ff807b192313c01d2e4d77a2db791bd7b53b680)
2011-11-25 14:03:21 +00:00
bottomQuad[ 0 ] = WindowVertex(outerRect.x() + bottomLeft.width(), outerRect.bottom() - bottom.height(), tx1, ty1);
bottomQuad[ 1 ] = WindowVertex(outerRect.right() - bottomRight.width(), outerRect.bottom() - bottom.height(), tx2, ty1);
bottomQuad[ 2 ] = WindowVertex(outerRect.right() - bottomRight.width(), outerRect.bottom(), tx2, ty2);
bottomQuad[ 3 ] = WindowVertex(outerRect.x() + bottomLeft.width(), outerRect.bottom(), tx1, ty2);
m_shadowQuads.append(bottomQuad);
fix NPOT shadows a) fixes the texture offset calculation b) arranges he shadow pixmaps as border in the texture to avoid interpolation issues. BUG: 280116 BUG: 282882 CCBUG: 291161 BUG: 293325 REVIEW: 103888
2012-02-08 18:31:17 +00:00
tx1 = 0.0;
tx2 = bottomLeft.width()/width;
ty1 = (height - bottomLeft.height())/height;
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
WindowQuad bottomLeftQuad(WindowQuadShadowBottomLeft);
simplify opengl shadow building code REVIEW: 103236 (cherry picked from commit 9ff807b192313c01d2e4d77a2db791bd7b53b680)
2011-11-25 14:03:21 +00:00
bottomLeftQuad[ 0 ] = WindowVertex(outerRect.x(), outerRect.bottom() - bottomLeft.height(), tx1, ty1);
bottomLeftQuad[ 1 ] = WindowVertex(outerRect.x() + bottomLeft.width(), outerRect.bottom() - bottomLeft.height(), tx2, ty1);
bottomLeftQuad[ 2 ] = WindowVertex(outerRect.x() + bottomLeft.width(), outerRect.bottom(), tx2, ty2);
bottomLeftQuad[ 3 ] = WindowVertex(outerRect.x(), outerRect.bottom(), tx1, ty2);
m_shadowQuads.append(bottomLeftQuad);
tx2 = left.width()/width;
fix NPOT shadows a) fixes the texture offset calculation b) arranges he shadow pixmaps as border in the texture to avoid interpolation issues. BUG: 280116 BUG: 282882 CCBUG: 291161 BUG: 293325 REVIEW: 103888
2012-02-08 18:31:17 +00:00
ty2 = ty1;
ty1 = topLeft.height()/height;
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
WindowQuad leftQuad(WindowQuadShadowLeft);
simplify opengl shadow building code REVIEW: 103236 (cherry picked from commit 9ff807b192313c01d2e4d77a2db791bd7b53b680)
2011-11-25 14:03:21 +00:00
leftQuad[ 0 ] = WindowVertex(outerRect.x(), outerRect.y() + topLeft.height(), tx1, ty1);
leftQuad[ 1 ] = WindowVertex(outerRect.x() + left.width(), outerRect.y() + topLeft.height(), tx2, ty1);
leftQuad[ 2 ] = WindowVertex(outerRect.x() + left.width(), outerRect.bottom() - bottomLeft.height(), tx2, ty2);
leftQuad[ 3 ] = WindowVertex(outerRect.x(), outerRect.bottom() - bottomLeft.height(), tx1, ty2);
m_shadowQuads.append(leftQuad);
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
}
bool SceneOpenGLShadow::prepareBackend()
{
simplify opengl shadow building code REVIEW: 103236 (cherry picked from commit 9ff807b192313c01d2e4d77a2db791bd7b53b680)
2011-11-25 14:03:21 +00:00
const QSize top(shadowPixmap(ShadowElementTop).size());
const QSize topRight(shadowPixmap(ShadowElementTopRight).size());
const QSize right(shadowPixmap(ShadowElementRight).size());
const QSize bottomRight(shadowPixmap(ShadowElementBottomRight).size());
const QSize bottom(shadowPixmap(ShadowElementBottom).size());
const QSize bottomLeft(shadowPixmap(ShadowElementBottomLeft).size());
const QSize left(shadowPixmap(ShadowElementLeft).size());
const QSize topLeft(shadowPixmap(ShadowElementTopLeft).size());
fix NPOT shadows a) fixes the texture offset calculation b) arranges he shadow pixmaps as border in the texture to avoid interpolation issues. BUG: 280116 BUG: 282882 CCBUG: 291161 BUG: 293325 REVIEW: 103888
2012-02-08 18:31:17 +00:00
const int width = topLeft.width() + top.width() + topRight.width();
const int height = topLeft.height() + left.height() + bottomLeft.height();
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
QImage image(width, height, QImage::Format_ARGB32);
image.fill(Qt::transparent);
QPainter p;
p.begin(&image);
p.drawPixmap(0, 0, shadowPixmap(ShadowElementTopLeft));
fix NPOT shadows a) fixes the texture offset calculation b) arranges he shadow pixmaps as border in the texture to avoid interpolation issues. BUG: 280116 BUG: 282882 CCBUG: 291161 BUG: 293325 REVIEW: 103888
2012-02-08 18:31:17 +00:00
p.drawPixmap(topLeft.width(), 0, shadowPixmap(ShadowElementTop));
p.drawPixmap(topLeft.width() + top.width(), 0, shadowPixmap(ShadowElementTopRight));
p.drawPixmap(0, topLeft.height(), shadowPixmap(ShadowElementLeft));
p.drawPixmap(width - right.width(), topRight.height(), shadowPixmap(ShadowElementRight));
p.drawPixmap(0, topLeft.height() + left.height(), shadowPixmap(ShadowElementBottomLeft));
p.drawPixmap(bottomLeft.width(), height - bottom.height(), shadowPixmap(ShadowElementBottom));
p.drawPixmap(bottomLeft.width() + bottom.width(), topRight.height() + right.height(), shadowPixmap(ShadowElementBottomRight));
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
p.end();
Better handling for making the compositing OpenGL context current With QtQuick2 it's possible that the scene graph rendering context either lives in an own thread or uses the main GUI thread. In the latter case it's the same thread as our compositing OpenGL context lives in. This means our basic assumption that between two rendering passes the context stays current does not hold. The code already ensured that before we start a rendering pass the context is made current, but there are many more possible cases. If we use OpenGL in areas not triggered by the rendering loop but in response to other events the context needs to be made current. This includes the loading and unloading of effects (some effects use OpenGL in the static effect check, in the ctor and dtor), background loading of texture data, lazy loading after first usage invoked by shortcut, etc. etc. To properly handle these cases new methods are added to EffectsHandler to make the compositing OpenGL context current. These calls delegate down into the scene. On non-OpenGL scenes they are noop, but on OpenGL they go into the backend and make the context current. In addition they ensure that Qt doesn't think that it's QOpenGLContext is current by calling doneCurrent() on the QOpenGLContext::currentContext(). This unfortunately causes an additional call to makeCurrent with a null context, but there is no other way to tell Qt - it doesn't notice when a different context is made current with low level API calls. In the multi-threaded architecture this doesn't matter as ::currentContext() returns null. A short evaluation showed that a transition to QOpenGLContext doesn't seem feasible. Qt only supports either GLX or EGL while KWin supports both and when entering the transition phase for Wayland, it would become extremely tricky if our native platform is X11, but we want a Wayland EGL context. A future solution might be to have a "KWin-QPA plugin" which uses either xcb or Wayland and hides everything from Qt. The API documentation is extended to describe when the effects-framework ensures that an OpenGL context is current. The effects are changed to make the context current in cases where it's not guaranteed. This has been done by looking for creation or deletion of GLTextures and Shaders. If there are other OpenGL usages outside the rendering loop, ctor/dtor this needs to be changed, too.
2013-11-22 14:05:36 +00:00
effects->makeOpenGLContextCurrent();
simplify opengl shadow building code REVIEW: 103236 (cherry picked from commit 9ff807b192313c01d2e4d77a2db791bd7b53b680)
2011-11-25 14:03:21 +00:00
delete m_texture;
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
m_texture = new GLTexture(image);
simplify opengl shadow building code REVIEW: 103236 (cherry picked from commit 9ff807b192313c01d2e4d77a2db791bd7b53b680)
2011-11-25 14:03:21 +00:00
Render Shadow with only one GL texture Copies the shadow parts into one image and creates a GLTexture from the image, so that we can render the complete shadow with just one texture and one painting pass. Should remove most of the overhead involved when rendering the new Shadows. As a side effect this should fix missing shadows with non-NPOT GPUs and a rendering glitch reported with NVIDIA. REVIEW: 101742
2011-06-23 17:06:12 +00:00
return true;
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
}
hasWaitSync -> blocksForRetrace and syncsToVBlank since that's not the same. also autodetect triple buffering REVIEW: 109783
2013-03-28 20:52:26 +00:00
SwapProfiler::SwapProfiler()
{
init();
}
void SwapProfiler::init()
{
m_time = 2 * 1000*1000; // we start with a long time mean of 2ms ...
m_counter = 0;
}
void SwapProfiler::begin()
{
m_timer.start();
}
char SwapProfiler::end()
{
// .. and blend in actual values.
// this way we prevent extremes from killing our long time mean
m_time = (10*m_time + m_timer.nsecsElapsed())/11;
if (++m_counter > 500) {
const bool blocks = m_time > 1000 * 1000; // 1ms, i get ~250µs and ~7ms w/o triple buffering...
And we got rid of KDebug Usages of kBacktrace got dropped.
2013-09-02 11:14:39 +00:00
qDebug() << "Triple buffering detection:" << QString(blocks ? QStringLiteral("NOT available") : QStringLiteral("Available")) <<
hasWaitSync -> blocksForRetrace and syncsToVBlank since that's not the same. also autodetect triple buffering REVIEW: 109783
2013-03-28 20:52:26 +00:00
" - Mean block time:" << m_time/(1000.0*1000.0) << "ms";
return blocks ? 'd' : 't';
}
return 0;
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
} // namespace
Reference in a new issue Copy permalink