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

93 lines
2.5 KiB
C
Raw Normal View History

Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 15:14:23 +00:00
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2012 Martin Gräßlin <mgraesslin@kde.org>
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/>.
*********************************************************************/
#ifndef KWIN_GLX_BACKEND_H
#define KWIN_GLX_BACKEND_H
#include "scene_opengl.h"
namespace KWin
{
class FBConfigInfo
{
public:
GLXFBConfig fbconfig;
int bind_texture_format;
int texture_targets;
int y_inverted;
int mipmap;
};
/**
* @brief OpenGL Backend using GLX over an X overlay window.
**/
class GlxBackend : public OpenGLBackend
{
public:
GlxBackend();
virtual ~GlxBackend();
virtual void screenGeometryChanged(const QSize &size);
virtual SceneOpenGL::TexturePrivate *createBackendTexture(SceneOpenGL::Texture *texture);
virtual void prepareRenderingFrame();
Get rid of the unreliable lastMask in the GL backend REVIEW: 109396
2013-03-10 21:18:30 +00:00
virtual void endRenderingFrame(const QRegion &damage);
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 15:14:23 +00:00
protected:
kwin: Rename flushBuffer() to present() This function doesn't flush any buffered commands, it presents or posts the color buffer to the surface to which the GL context is bound.
2012-10-07 11:43:31 +00:00
virtual void present();
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 15:14:23 +00:00
private:
void init();
bool initBuffer();
bool initDrawableConfigs();
void waitSync();
bool initRenderingContext();
kwin: Simplify GLXBackend::initBufferConfigs() Use glXChooseFBConfig() instead of glXGetFBConfigs(), and prefer the first usable configuration instead of the last. Also rename initBufferConfigs() to initFbConfig().
2013-03-11 15:16:05 +00:00
bool initFbConfig();
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
void setSwapInterval(int interval);
Split out the windowing system related part of SceneOpenGL The handling for creating and managing the OpenGL context is split out of the SceneOpenGL into the abstract OpenGLBackend and it's two subclasses GlxBackend and EglOnXBackend. The backends take care of creating the OpenGL context on the windowing system, e.g. on glx an OpenGL context on the overlay window is created and in the egl case an EGL context is created. This means that the SceneOpenGL itself does not have to care about the specific underlying infrastructure. Furthermore the backend provides the Textures for the specific texture from pixmap operations. For that in each of the backend files an additional subclass of the TexturePrivate is defined. These subclasses hold the EglImage and GLXPixmap respectively. The backend is able to create such a private texture and for that the ctor of the Texture is changed to take the backend as a parameter and the Scene provides a factory method for creating Textures. To make this work inside Window the Textures are now hold as pointers which seems a better choice anyway as to the member functions pointers are passed.
2012-08-26 15:14:23 +00:00
kwin: Require Xcomposite 0.3 for OpenGL compositing Remove support for OpenGL compositing without using a composite overlay window. With this change kwin now also requires a double-buffered framebuffer configuration.
2013-03-11 15:27:24 +00:00
Window window;
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
FBConfigInfo fbcdrawableinfo[ 32 + 1 ];
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
GLXFBConfig fbconfig;
kwin: Require Xcomposite 0.3 for OpenGL compositing Remove support for OpenGL compositing without using a composite overlay window. With this change kwin now also requires a double-buffered framebuffer configuration.
2013-03-11 15:27:24 +00:00
GLXWindow glxWindow;
kwin: Rename some variables in GLXBackend ctxbuffer → ctx glxbuffer → glxDrawable buffer → drawable fbcbuffer → fbconfig fbcbuffer_db → fbconfig_db fbcbuffer_nondb → fbconfig_nondb
2013-03-11 15:05:47 +00:00
GLXContext ctx;
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
bool haveSwapInterval;
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
friend class GlxTexture;
};
/**
* @brief Texture using an GLXPixmap.
**/
class GlxTexture : public SceneOpenGL::TexturePrivate
{
public:
virtual ~GlxTexture();
virtual void onDamage();
virtual void findTarget();
virtual bool loadTexture(const Pixmap& pix, const QSize& size, int depth);
virtual OpenGLBackend *backend();
private:
friend class GlxBackend;
GlxTexture(SceneOpenGL::Texture *texture, GlxBackend *backend);
SceneOpenGL::Texture *q;
GlxBackend *m_backend;
GLXPixmap m_glxpixmap; // the glx pixmap the texture is bound to
};
} // namespace
#endif // KWIN_GLX_BACKEND_H
Reference in a new issue Copy permalink