vitalif
/
kwin
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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
icc-effect-5.14.5
Philipp Knechtges 2011-07-18 17:55:39 +02:00
parent 9c2d6f8fdc
commit 4f50a8df3c
8 changed files with 462 additions and 293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

292
libkwineffects/kwingltexture.cpp
View File

@ -26,6 +26,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "kwinglutils_funcs.h"
#include "kwinglutils.h"
#include "kwingltexture_p.h"
#include <QPixmap>
#include <QImage>
#include <QVector2D>
@ -40,52 +42,62 @@ namespace KWin
// GLTexture
//****************************************
bool GLTexture::sNPOTTextureSupported = false;
bool GLTexture::sFramebufferObjectSupported = false;
bool GLTexture::sSaturationSupported = false;
bool GLTexturePrivate::sNPOTTextureSupported = false;
bool GLTexturePrivate::sFramebufferObjectSupported = false;
bool GLTexturePrivate::sSaturationSupported = false;
GLTexture::GLTexture()
: d_ptr(new GLTexturePrivate())
{
}
GLTexture::GLTexture(GLTexturePrivate& dd)
: d_ptr(&dd)
{
}
GLTexture::GLTexture(const GLTexture& tex)
: d_ptr(tex.d_ptr)
{
init();
}
GLTexture::GLTexture(const QImage& image, GLenum target)
: d_ptr(new GLTexturePrivate())
{
init();
load(image, target);
}
GLTexture::GLTexture(const QPixmap& pixmap, GLenum target)
: d_ptr(new GLTexturePrivate())
{
init();
load(pixmap, target);
}
GLTexture::GLTexture(const QString& fileName)
: d_ptr(new GLTexturePrivate())
{
init();
load(fileName);
}
GLTexture::GLTexture(int width, int height)
: d_ptr(new GLTexturePrivate())
{
init();
Q_D(GLTexture);
if (NPOTTextureSupported() || (isPowerOfTwo(width) && isPowerOfTwo(height))) {
mTarget = GL_TEXTURE_2D;
mScale.setWidth(1.0 / width);
mScale.setHeight(1.0 / height);
mSize = QSize(width, height);
can_use_mipmaps = true;
d->m_target = GL_TEXTURE_2D;
d->m_scale.setWidth(1.0 / width);
d->m_scale.setHeight(1.0 / height);
d->m_size = QSize(width, height);
d->m_canUseMipmaps = true;
glGenTextures(1, &mTexture);
glGenTextures(1, &d->m_texture);
bind();
#ifdef KWIN_HAVE_OPENGLES
// format and internal format have to match in ES, GL_RGBA8 and GL_BGRA are not available
// see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glTexImage2D.xml
glTexImage2D(mTarget, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glTexImage2D(d->m_target, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
#else
glTexImage2D(mTarget, 0, GL_RGBA8, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, 0);
glTexImage2D(d->m_target, 0, GL_RGBA8, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, 0);
#endif
unbind();
}
@ -93,26 +105,38 @@ GLTexture::GLTexture(int width, int height)
GLTexture::~GLTexture()
{
delete m_vbo;
discard();
assert(mUnnormalizeActive == 0);
assert(mNormalizeActive == 0);
}
void GLTexture::init()
GLTexture& GLTexture::operator = (const GLTexture& tex)
{
mTexture = None;
mTarget = 0;
mFilter = 0;
y_inverted = false;
can_use_mipmaps = false;
has_valid_mipmaps = false;
mUnnormalizeActive = 0;
mNormalizeActive = 0;
d_ptr = tex.d_ptr;
return *this;
}
GLTexturePrivate::GLTexturePrivate()
{
m_texture = 0;
m_target = 0;
m_filter = 0;
m_yInverted = false;
m_canUseMipmaps = false;
m_hasValidMipmaps = false;
m_unnormalizeActive = 0;
m_normalizeActive = 0;
m_vbo = 0;
}
void GLTexture::initStatic()
GLTexturePrivate::~GLTexturePrivate()
{
if (m_vbo != 0) {
delete m_vbo;
}
if (m_texture != 0) {
glDeleteTextures(1, &m_texture);
}
}
void GLTexturePrivate::initStatic()
{
#ifdef KWIN_HAVE_OPENGLES
sNPOTTextureSupported = true;
@ -129,22 +153,28 @@ void GLTexture::initStatic()
bool GLTexture::isNull() const
{
return mTexture == None;
Q_D(const GLTexture);
return None == d->m_texture;
}
QSize GLTexture::size() const
{
return mSize;
Q_D(const GLTexture);
return d->m_size;
}
bool GLTexture::load(const QImage& image, GLenum target)
{
// decrease the reference counter for the old texture
d_ptr = new GLTexturePrivate();
Q_D(GLTexture);
if (image.isNull())
return false;
QImage img = image;
mTarget = target;
d->m_target = target;
#ifndef KWIN_HAVE_OPENGLES
if (mTarget != GL_TEXTURE_RECTANGLE_ARB) {
if (d->m_target != GL_TEXTURE_RECTANGLE_ARB) {
#endif
if (!NPOTTextureSupported()
&& (!isPowerOfTwo(image.width()) || !isPowerOfTwo(image.height()))) {
@ -152,33 +182,33 @@ bool GLTexture::load(const QImage& image, GLenum target)
img = img.scaled(nearestPowerOfTwo(image.width()),
nearestPowerOfTwo(image.height()));
}
mScale.setWidth(1.0 / img.width());
mScale.setHeight(1.0 / img.height());
can_use_mipmaps = true;
d->m_scale.setWidth(1.0 / img.width());
d->m_scale.setHeight(1.0 / img.height());
d->m_canUseMipmaps = true;
#ifndef KWIN_HAVE_OPENGLES
} else {
mScale.setWidth(1.0);
mScale.setHeight(1.0);
can_use_mipmaps = false;
d->m_scale.setWidth(1.0);
d->m_scale.setHeight(1.0);
d->m_canUseMipmaps = false;
}
#endif
setFilter(GL_LINEAR);
mSize = img.size();
y_inverted = true;
d->m_size = img.size();
d->m_yInverted = true;
img = convertToGLFormat(img);
img = d->convertToGLFormat(img);
setDirty();
if (isNull()) {
glGenTextures(1, &mTexture);
glGenTextures(1, &d->m_texture);
}
bind();
#ifdef KWIN_HAVE_OPENGLES
// format and internal format have to match in ES, GL_RGBA8 and GL_BGRA are not available
// see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glTexImage2D.xml
glTexImage2D(mTarget, 0, GL_RGBA, img.width(), img.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, img.bits());
glTexImage2D(d->m_target, 0, GL_RGBA, img.width(), img.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, img.bits());
#else
glTexImage2D(mTarget, 0, GL_RGBA8, img.width(), img.height(), 0,
glTexImage2D(d->m_target, 0, GL_RGBA8, img.width(), img.height(), 0,
GL_BGRA, GL_UNSIGNED_BYTE, img.bits());
#endif
unbind();
@ -201,37 +231,47 @@ bool GLTexture::load(const QString& fileName)
void GLTexture::discard()
{
setDirty();
if (mTexture != None)
glDeleteTextures(1, &mTexture);
mTexture = None;
d_ptr = new GLTexturePrivate();
}
void GLTexturePrivate::bind()
{
#ifndef KWIN_HAVE_OPENGLES
glEnable(m_target);
#endif
glBindTexture(m_target, m_texture);
enableFilter();
}
void GLTexture::bind()
{
Q_D(GLTexture);
d->bind();
}
void GLTexturePrivate::unbind()
{
glBindTexture(m_target, 0);
#ifndef KWIN_HAVE_OPENGLES
glEnable(mTarget);
glDisable(m_target);
#endif
glBindTexture(mTarget, mTexture);
enableFilter();
}
void GLTexture::unbind()
{
glBindTexture(mTarget, 0);
#ifndef KWIN_HAVE_OPENGLES
glDisable(mTarget);
#endif
Q_D(GLTexture);
d->unbind();
}
void GLTexture::render(QRegion region, const QRect& rect)
{
if (rect.size() != m_cachedSize) {
m_cachedSize = rect.size();
Q_D(GLTexture);
if (rect.size() != d->m_cachedSize) {
d->m_cachedSize = rect.size();
QRect r(rect);
r.moveTo(0, 0);
if (!m_vbo) {
m_vbo = new GLVertexBuffer(KWin::GLVertexBuffer::Static);
if (!d->m_vbo) {
d->m_vbo = new GLVertexBuffer(KWin::GLVertexBuffer::Static);
}
const float verts[ 4 * 2 ] = {
// NOTICE: r.x/y could be replaced by "0", but that would make it unreadable...
@ -241,12 +281,12 @@ void GLTexture::render(QRegion region, const QRect& rect)
r.x() + rect.width(), r.y() + rect.height()
};
const float texcoords[ 4 * 2 ] = {
0.0f, y_inverted ? 0.0f : 1.0f, // y needs to be swapped (normalized coords)
0.0f, y_inverted ? 1.0f : 0.0f,
1.0f, y_inverted ? 0.0f : 1.0f,
1.0f, y_inverted ? 1.0f : 0.0f
0.0f, d->m_yInverted ? 0.0f : 1.0f, // y needs to be swapped (normalized coords)
0.0f, d->m_yInverted ? 1.0f : 0.0f,
1.0f, d->m_yInverted ? 0.0f : 1.0f,
1.0f, d->m_yInverted ? 1.0f : 0.0f
};
m_vbo->setData(4, 2, verts, texcoords);
d->m_vbo->setData(4, 2, verts, texcoords);
}
QMatrix4x4 translation;
translation.translate(rect.x(), rect.y());
@ -257,7 +297,7 @@ void GLTexture::render(QRegion region, const QRect& rect)
} else {
pushMatrix(translation);
}
m_vbo->render(region, GL_TRIANGLE_STRIP);
d->m_vbo->render(region, GL_TRIANGLE_STRIP);
if (ShaderManager::instance()->isShaderBound()) {
GLShader *shader = ShaderManager::instance()->getBoundShader();
shader->setUniform(GLShader::WindowTransformation, QMatrix4x4());
@ -268,85 +308,94 @@ void GLTexture::render(QRegion region, const QRect& rect)
GLuint GLTexture::texture() const
{
return mTexture;
Q_D(const GLTexture);
return d->m_texture;
}
GLenum GLTexture::target() const
{
return mTarget;
Q_D(const GLTexture);
return d->m_target;
}
GLenum GLTexture::filter() const
{
return mFilter;
Q_D(const GLTexture);
return d->m_filter;
}
bool GLTexture::isDirty() const
{
return has_valid_mipmaps;
Q_D(const GLTexture);
return d->m_hasValidMipmaps;
}
void GLTexture::setTexture(GLuint texture)
{
Q_D(GLTexture);
discard();
mTexture = texture;
d->m_texture = texture;
}
void GLTexture::setTarget(GLenum target)
{
mTarget = target;
Q_D(GLTexture);
d->m_target = target;
}
void GLTexture::setFilter(GLenum filter)
{
mFilter = filter;
Q_D(GLTexture);
d->m_filter = filter;
}
void GLTexture::setWrapMode(GLenum mode)
{
Q_D(GLTexture);
bind();
glTexParameteri(mTarget, GL_TEXTURE_WRAP_S, mode);
glTexParameteri(mTarget, GL_TEXTURE_WRAP_T, mode);
glTexParameteri(d->m_target, GL_TEXTURE_WRAP_S, mode);
glTexParameteri(d->m_target, GL_TEXTURE_WRAP_T, mode);
unbind();
}
void GLTexture::setDirty()
{
has_valid_mipmaps = false;
Q_D(GLTexture);
d->m_hasValidMipmaps = false;
}
void GLTexture::enableFilter()
void GLTexturePrivate::enableFilter()
{
if (mFilter == GL_LINEAR_MIPMAP_LINEAR) {
if (m_filter == GL_LINEAR_MIPMAP_LINEAR) {
// trilinear filtering requested, but is it possible?
if (NPOTTextureSupported()
&& framebufferObjectSupported()
&& can_use_mipmaps) {
glTexParameteri(mTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(mTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (!has_valid_mipmaps) {
glGenerateMipmap(mTarget);
has_valid_mipmaps = true;
if (sNPOTTextureSupported
&& sFramebufferObjectSupported
&& m_canUseMipmaps) {
glTexParameteri(m_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(m_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (!m_hasValidMipmaps) {
glGenerateMipmap(m_target);
m_hasValidMipmaps = true;
}
} else {
// can't use trilinear, so use bilinear
setFilter(GL_LINEAR);
glTexParameteri(mTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(mTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
m_filter = GL_LINEAR;
glTexParameteri(m_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(m_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
} else if (mFilter == GL_LINEAR) {
glTexParameteri(mTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(mTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
} else if (m_filter == GL_LINEAR) {
glTexParameteri(m_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(m_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
} else {
// if neither trilinear nor bilinear, default to fast filtering
setFilter(GL_NEAREST);
glTexParameteri(mTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(mTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
m_filter = GL_NEAREST;
glTexParameteri(m_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(m_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
}
QImage GLTexture::convertToGLFormat(const QImage& img) const
QImage GLTexturePrivate::convertToGLFormat(const QImage& img) const
{
// Copied from Qt's QGLWidget::convertToGLFormat()
QImage res;
@ -410,7 +459,52 @@ QImage GLTexture::convertToGLFormat(const QImage& img) const
bool GLTexture::isYInverted() const
{
return y_inverted;
Q_D(const GLTexture);
return d->m_yInverted;
}
void GLTexture::setYInverted(bool inverted)
{
Q_D(GLTexture);
d->m_yInverted = inverted;
}
int GLTexture::width() const
{
Q_D(const GLTexture);
return d->m_size.width();
}
int GLTexture::height() const
{
Q_D(const GLTexture);
return d->m_size.height();
}
bool GLTexture::NPOTTextureSupported()
{
return GLTexturePrivate::sNPOTTextureSupported;
}
bool GLTexture::framebufferObjectSupported()
{
return GLTexturePrivate::sFramebufferObjectSupported;
}
bool GLTexture::saturationSupported()
{
return GLTexturePrivate::sSaturationSupported;
}
void GLTexture::release()
{
Q_D(GLTexture);
d->release();
}
void GLTexturePrivate::release()
{
// nothing to do because we are not bound to any specific data
}
} // namespace KWin

63
libkwineffects/kwingltexture.h
View File

@ -25,7 +25,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "kwinglobals.h"
#include <QtCore/QSize>
#include <QtCore/QSharedData>
#include <QSharedPointer>
#include <QExplicitlySharedDataPointer>
class QImage;
class QPixmap;
@ -37,37 +38,45 @@ namespace KWin
{
class GLVertexBuffer;
class GLTexturePrivate;
class KWIN_EXPORT GLTexture
: public QSharedData
{
public:
GLTexture();
GLTexture(const GLTexture& tex);
explicit GLTexture(const QImage& image, GLenum target = GL_TEXTURE_2D);
explicit GLTexture(const QPixmap& pixmap, GLenum target = GL_TEXTURE_2D);
GLTexture(const QString& fileName);
GLTexture(int width, int height);
virtual ~GLTexture();
GLTexture & operator = (const GLTexture& tex);
bool isNull() const;
QSize size() const;
int width() const {
return mSize.width(); /// @since 4.5
}
int height() const {
return mSize.height(); /// @since 4.5
}
int width() const;
int height() const;
/**
* @since 4.7
**/
bool isYInverted() const;
/**
* @since 4.8
**/
void setYInverted(bool inverted);
virtual bool load(const QImage& image, GLenum target = GL_TEXTURE_2D);
virtual bool load(const QPixmap& pixmap, GLenum target = GL_TEXTURE_2D);
virtual bool load(const QString& fileName);
virtual void discard();
virtual void bind();
virtual void unbind();
void bind();
void unbind();
/**
* Release the data which is bound to the texture.
* @since 4.8
**/
void release();
void render(QRegion region, const QRect& rect);
GLuint texture() const;
@ -80,41 +89,19 @@ public:
void setWrapMode(GLenum mode);
virtual void setDirty();
static void initStatic();
static bool NPOTTextureSupported() {
return sNPOTTextureSupported;
}
static bool framebufferObjectSupported() {
return sFramebufferObjectSupported;
}
static bool saturationSupported() {
return sSaturationSupported;
}
static bool NPOTTextureSupported();
static bool framebufferObjectSupported();
static bool saturationSupported();
protected:
void enableFilter();
QImage convertToGLFormat(const QImage& img) const;
GLuint mTexture;
GLenum mTarget;
GLenum mFilter;
QSize mSize;
QSizeF mScale; // to un-normalize GL_TEXTURE_2D
bool y_inverted; // texture has y inverted
bool can_use_mipmaps;
bool has_valid_mipmaps;
QExplicitlySharedDataPointer<GLTexturePrivate> d_ptr;
GLTexture(GLTexturePrivate& dd);
private:
void init();
int mUnnormalizeActive; // 0 - no, otherwise refcount
int mNormalizeActive; // 0 - no, otherwise refcount
GLVertexBuffer* m_vbo;
QSize m_cachedSize;
static bool sNPOTTextureSupported;
static bool sFramebufferObjectSupported;
static bool sSaturationSupported;
Q_DISABLE_COPY(GLTexture)
Q_DECLARE_PRIVATE(GLTexture);
};
} // namespace

74
libkwineffects/kwingltexture_p.h Normal file
View File

@ -0,0 +1,74 @@
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2006-2007 Rivo Laks <rivolaks@hot.ee>
Copyright (C) 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
Copyright (C) 2011 Philipp Knechtges <philipp-dev@knechtges.com>
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_GLTEXTURE_P_H
#define KWIN_GLTEXTURE_P_H
#include "kwinconfig.h" // KWIN_HAVE_OPENGL
#include "kwinglobals.h"
#include <QtCore/QSize>
#include <QtCore/QSharedData>
namespace KWin
{
class KWIN_EXPORT GLTexturePrivate
: public QSharedData
{
public:
GLTexturePrivate();
virtual ~GLTexturePrivate();
virtual void bind();
virtual void unbind();
virtual void release();
void enableFilter();
QImage convertToGLFormat(const QImage& img) const;
GLuint m_texture;
GLenum m_target;
GLenum m_filter;
QSize m_size;
QSizeF m_scale; // to un-normalize GL_TEXTURE_2D
bool m_yInverted; // texture has y inverted
bool m_canUseMipmaps;
bool m_hasValidMipmaps;
int m_unnormalizeActive; // 0 - no, otherwise refcount
int m_normalizeActive; // 0 - no, otherwise refcount
GLVertexBuffer* m_vbo;
QSize m_cachedSize;
static void initStatic();
static bool sNPOTTextureSupported;
static bool sFramebufferObjectSupported;
static bool sSaturationSupported;
private:
Q_DISABLE_COPY(GLTexturePrivate)
};
} // namespace
#endif

5
libkwineffects/kwinglutils.cpp
View File

@ -21,6 +21,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "kwinglutils.h"
// need to call GLTexturePrivate::initStatic()
#include "kwingltexture_p.h"
#include "kwinglobals.h"
#include "kwineffects.h"
#include "kwinglplatform.h"
@ -113,7 +116,7 @@ void initGL()
// handle OpenGL extensions functions
glResolveFunctions();
GLTexture::initStatic();
GLTexturePrivate::initStatic();
GLRenderTarget::initStatic();
GLVertexBuffer::initStatic();
}

66
scene_opengl.cpp
View File

@ -268,55 +268,43 @@ void SceneOpenGL::windowOpacityChanged(KWin::Toplevel* t)
// SceneOpenGL::Texture
//****************************************
SceneOpenGL::Texture::Texture() : GLTexture()
SceneOpenGL::Texture::Texture() : GLTexture(*new TexturePrivate())
{
init();
}
SceneOpenGL::Texture::Texture(const Pixmap& pix, const QSize& size, int depth) : GLTexture()
SceneOpenGL::Texture::Texture(TexturePrivate& dd) : GLTexture(dd)
{
}
SceneOpenGL::Texture::Texture(const SceneOpenGL::Texture& tex) : GLTexture(*tex.d_ptr)
{
}
SceneOpenGL::Texture::Texture(const Pixmap& pix, const QSize& size, int depth)
: GLTexture(*new TexturePrivate())
{
init();
load(pix, size, depth);
}
SceneOpenGL::Texture::Texture(const QPixmap& pix, GLenum target)
: GLTexture()
: GLTexture(*new TexturePrivate())
{
init();
load(pix, target);
}
SceneOpenGL::Texture::~Texture()
{
discard();
}
void SceneOpenGL::Texture::createTexture()
SceneOpenGL::Texture& SceneOpenGL::Texture::operator = (const SceneOpenGL::Texture& tex)
{
glGenTextures(1, &mTexture);
d_ptr = tex.d_ptr;
return *this;
}
void SceneOpenGL::Texture::discard()
{
if (mTexture != None)
release();
GLTexture::discard();
}
QRegion SceneOpenGL::Texture::optimizeBindDamage(const QRegion& reg, int limit)
{
if (reg.rects().count() <= 1)
return reg;
// try to reduce the number of rects, as especially with SHM mode every rect
// causes X roundtrip, even for very small areas - so, when the size difference
// between all the areas and the bounding rectangle is small, simply use
// only the bounding rectangle
int size = 0;
foreach (const QRect & r, reg.rects())
size += r.width() * r.height();
if (reg.boundingRect().width() * reg.boundingRect().height() - size < limit)
return reg.boundingRect();
return reg;
d_ptr = new TexturePrivate();
}
bool SceneOpenGL::Texture::load(const Pixmap& pix, const QSize& size,
@ -337,6 +325,7 @@ bool SceneOpenGL::Texture::load(const QImage& image, GLenum target)
bool SceneOpenGL::Texture::load(const QPixmap& pixmap, GLenum target)
{
Q_D(Texture);
if (pixmap.isNull())
return false;
@ -345,8 +334,6 @@ bool SceneOpenGL::Texture::load(const QPixmap& pixmap, GLenum target)
return GLTexture::load(pixmap.toImage(), target);
}
y_inverted = true;
// use the X11 pixmap provided by Qt
return load(pixmap.handle(), pixmap.size(), pixmap.depth());
}
@ -374,9 +361,16 @@ SceneOpenGL::Window::~Window()
bool SceneOpenGL::Window::bindTexture()
{
#ifndef KWIN_HAVE_OPENGLES
if (texture.texture() != None && toplevel->damage().isEmpty()) {
// texture doesn't need updating, just bind it
glBindTexture(texture.target(), texture.texture());
if (!texture.isNull()) {
if (toplevel->damage().isEmpty()) {
// texture doesn't need updating, just bind it
glBindTexture(texture.target(), texture.texture());
} else {
// bind() updates the texture automatically e.g. in case the glx pixmap binding
// is strict
texture.bind();
toplevel->resetDamage(QRect(toplevel->clientPos(), toplevel->clientSize()));
}
return true;
}
#endif
@ -384,8 +378,10 @@ bool SceneOpenGL::Window::bindTexture()
Pixmap pix = toplevel->windowPixmap();
if (pix == None)
return false;
bool success = texture.load(pix, toplevel->size(), toplevel->depth(),
toplevel->damage());
if (success)
toplevel->resetDamage(QRect(toplevel->clientPos(), toplevel->clientSize()));
else
@ -417,7 +413,7 @@ void SceneOpenGL::Window::checkTextureSize()
// when the window's composite pixmap is discarded, undo binding it to the texture
void SceneOpenGL::Window::pixmapDiscarded()
{
texture.release();
texture.discard();
}
QMatrix4x4 SceneOpenGL::Window::transformation(int mask, const WindowPaintData &data) const
@ -640,7 +636,7 @@ void SceneOpenGL::Window::paintDecoration(const QPixmap* decoration, TextureType
}
if (decorationTexture->texture() != None && !updateDeco) {
// texture doesn't need updating, just bind it
glBindTexture(decorationTexture->target(), decorationTexture->texture());
decorationTexture->bind();
} else if (!decoration->isNull()) {
bool success = decorationTexture->load(*decoration);
if (!success) {

39
scene_opengl.h
View File

@ -26,6 +26,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "shadow.h"
#include "kwinglutils.h"
#include "kwingltexture_p.h"
#ifdef HAVE_XSHM
#include <X11/extensions/XShm.h>
@ -41,6 +42,7 @@ class SceneOpenGL
public:
class EffectFrame;
class Texture;
class TexturePrivate;
class Window;
SceneOpenGL(Workspace* ws);
virtual ~SceneOpenGL();
@ -100,40 +102,51 @@ private:
bool debug;
};
class SceneOpenGL::TexturePrivate
: public GLTexturePrivate
{
public:
TexturePrivate();
virtual ~TexturePrivate();
virtual void bind();
virtual void unbind();
virtual void release();
#ifndef KWIN_HAVE_OPENGLES
GLXPixmap m_glxpixmap; // the glx pixmap the texture is bound to, only for tfp_mode
#endif
private:
Q_DISABLE_COPY(TexturePrivate)
};
class SceneOpenGL::Texture
: public GLTexture
{
public:
Texture();
Texture(const Texture& tex);
Texture(const QPixmap& pix, GLenum target = GL_TEXTURE_2D);
virtual ~Texture();
Texture & operator = (const Texture& tex);
using GLTexture::load;
virtual bool load(const QImage& image, GLenum target = GL_TEXTURE_2D);
virtual bool load(const QPixmap& pixmap, GLenum target = GL_TEXTURE_2D);
virtual void discard();
virtual void release(); // undo the tfp_mode binding
virtual void bind();
virtual void unbind();
void setYInverted(bool inverted) {
y_inverted = inverted;
}
protected:
Texture(const Pixmap& pix, const QSize& size, int depth);
void findTarget();
QRegion optimizeBindDamage(const QRegion& reg, int limit);
void createTexture();
virtual bool load(const Pixmap& pix, const QSize& size, int depth,
QRegion region);
virtual bool load(const Pixmap& pix, const QSize& size, int depth);
private:
void init();
Texture(TexturePrivate& dd);
#ifndef KWIN_HAVE_OPENGLES
GLXPixmap glxpixmap; // the glx pixmap the texture is bound to, only for tfp_mode
#endif
private:
Q_DECLARE_PRIVATE(Texture);
friend class SceneOpenGL::Window;
};

70
scene_opengl_egl.cpp
View File

@ -210,65 +210,71 @@ void SceneOpenGL::flushBuffer(int mask, QRegion damage)
// SceneOpenGL::Texture
//****************************************
void SceneOpenGL::Texture::init()
SceneOpenGL::TexturePrivate::TexturePrivate()
{
findTarget();
m_target = GL_TEXTURE_2D;
}
void SceneOpenGL::Texture::release()
SceneOpenGL::TexturePrivate::~TexturePrivate()
{
mTexture = None;
}
void SceneOpenGL::Texture::findTarget()
{
mTarget = GL_TEXTURE_2D;
Q_D(Texture);
d->m_target = GL_TEXTURE_2D;
}
void SceneOpenGL::TexturePrivate::release()
{
}
bool SceneOpenGL::Texture::load(const Pixmap& pix, const QSize& size,
int depth, QRegion region)
{
// decrease the reference counter for the old texture
d_ptr = new TexturePrivate();
Q_D(Texture);
Q_UNUSED(depth)
Q_UNUSED(region)
if (pix == None)
return false;
if (mTexture == None) {
createTexture();
bind();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
const EGLint attribs[] = {
EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
EGL_NONE
};
EGLImageKHR image = eglCreateImageKHR(dpy, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR,
(EGLClientBuffer)pix, attribs);
glGenTextures(1, &d->m_texture);
bind();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
const EGLint attribs[] = {
EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
EGL_NONE
};
EGLImageKHR image = eglCreateImageKHR(dpy, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR,
(EGLClientBuffer)pix, attribs);
if (EGL_NO_IMAGE_KHR == image) {
kDebug(1212) << "failed to create egl image";
unbind();
return false;
}
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
eglDestroyImageKHR(dpy, image);
if (EGL_NO_IMAGE_KHR == image) {
kDebug(1212) << "failed to create egl image";
unbind();
checkGLError("load texture");
setYInverted(true);
mSize = size;
return false;
}
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
eglDestroyImageKHR(dpy, image);
unbind();
checkGLError("load texture");
setYInverted(true);
d->m_size = size;
return true;
}
void SceneOpenGL::Texture::bind()
void SceneOpenGL::TexturePrivate::bind()
{
GLTexture::bind();
GLTexturePrivate::bind();
}
void SceneOpenGL::Texture::unbind()
void SceneOpenGL::TexturePrivate::unbind()
{
GLTexture::unbind();
GLTexturePrivate::unbind();
}

146
scene_opengl_glx.cpp
View File

@ -55,6 +55,7 @@ SceneOpenGL::SceneOpenGL(Workspace* ws)
return; // error
// Initialize OpenGL
initGL();
GLPlatform *glPlatform = GLPlatform::instance();
if (glPlatform->isSoftwareEmulation()) {
kError(1212) << "OpenGL Software Rasterizer detected. Falling back to XRender.";
@ -544,33 +545,38 @@ void SceneOpenGL::flushBuffer(int mask, QRegion damage)
// SceneOpenGL::Texture
//****************************************
void SceneOpenGL::Texture::init()
SceneOpenGL::TexturePrivate::TexturePrivate()
{
glxpixmap = None;
m_glxpixmap = None;
}
void SceneOpenGL::Texture::release()
SceneOpenGL::TexturePrivate::~TexturePrivate()
{
if (glxpixmap != None) {
release();
}
void SceneOpenGL::TexturePrivate::release()
{
if (m_glxpixmap != None) {
if (!options->glStrictBinding) {
glXReleaseTexImageEXT(display(), glxpixmap, GLX_FRONT_LEFT_EXT);
glXReleaseTexImageEXT(display(), m_glxpixmap, GLX_FRONT_LEFT_EXT);
}
glXDestroyPixmap(display(), glxpixmap);
glxpixmap = None;
glXDestroyPixmap(display(), m_glxpixmap);
}
}
void SceneOpenGL::Texture::findTarget()
{
Q_D(Texture);
unsigned int new_target = 0;
if (glXQueryDrawable && glxpixmap != None)
glXQueryDrawable(display(), glxpixmap, GLX_TEXTURE_TARGET_EXT, &new_target);
if (glXQueryDrawable && d->m_glxpixmap != None)
glXQueryDrawable(display(), d->m_glxpixmap, GLX_TEXTURE_TARGET_EXT, &new_target);
// HACK: this used to be a hack for Xgl.
// without this hack the NVIDIA blob aborts when trying to bind a texture from
// a pixmap icon
if (new_target == 0) {
if (NPOTTextureSupported() ||
(isPowerOfTwo(mSize.width()) && isPowerOfTwo(mSize.height()))) {
(isPowerOfTwo(d->m_size.width()) && isPowerOfTwo(d->m_size.height()))) {
new_target = GLX_TEXTURE_2D_EXT;
} else {
new_target = GLX_TEXTURE_RECTANGLE_EXT;
@ -578,14 +584,14 @@ void SceneOpenGL::Texture::findTarget()
}
switch(new_target) {
case GLX_TEXTURE_2D_EXT:
mTarget = GL_TEXTURE_2D;
mScale.setWidth(1.0f / mSize.width());
mScale.setHeight(1.0f / mSize.height());
d->m_target = GL_TEXTURE_2D;
d->m_scale.setWidth(1.0f / d->m_size.width());
d->m_scale.setHeight(1.0f / d->m_size.height());
break;
case GLX_TEXTURE_RECTANGLE_EXT:
mTarget = GL_TEXTURE_RECTANGLE_ARB;
mScale.setWidth(1.0f);
mScale.setHeight(1.0f);
d->m_target = GL_TEXTURE_RECTANGLE_ARB;
d->m_scale.setWidth(1.0f);
d->m_scale.setHeight(1.0f);
break;
default:
abort();
@ -595,6 +601,10 @@ void SceneOpenGL::Texture::findTarget()
bool SceneOpenGL::Texture::load(const Pixmap& pix, const QSize& size,
int depth, QRegion region)
{
// decrease the reference counter for the old texture
d_ptr = new TexturePrivate();
Q_D(Texture);
#ifdef CHECK_GL_ERROR
checkGLError("TextureLoad1");
#endif
@ -606,78 +616,65 @@ bool SceneOpenGL::Texture::load(const Pixmap& pix, const QSize& size,
return false;
}
mSize = size;
if (mTexture == None || !region.isEmpty()) {
// new texture, or texture contents changed; mipmaps now invalid
setDirty();
}
d->m_size = size;
d->m_yInverted = true;
// new texture, or texture contents changed; mipmaps now invalid
setDirty();
#ifdef CHECK_GL_ERROR
checkGLError("TextureLoad2");
#endif
// tfp mode, simply bind the pixmap to texture
if (mTexture == None)
createTexture();
glGenTextures(1, &d->m_texture);
// The GLX pixmap references the contents of the original pixmap, so it doesn't
// need to be recreated when the contents change.
// The texture may or may not use the same storage depending on the EXT_tfp
// implementation. When options->glStrictBinding is true, the texture uses
// a different storage and needs to be updated with a call to
// glXBindTexImageEXT() when the contents of the pixmap has changed.
if (glxpixmap != None)
glBindTexture(mTarget, mTexture);
else {
int attrs[] = {
GLX_TEXTURE_FORMAT_EXT, fbcdrawableinfo[ depth ].bind_texture_format,
GLX_MIPMAP_TEXTURE_EXT, fbcdrawableinfo[ depth ].mipmap,
None, None, None
};
// Specifying the texture target explicitly is reported to cause a performance
// regression with R300G (see bug #256654).
if (GLPlatform::instance()->driver() != Driver_R300G) {
if ((fbcdrawableinfo[ depth ].texture_targets & GLX_TEXTURE_2D_BIT_EXT) &&
(GLTexture::NPOTTextureSupported() ||
(isPowerOfTwo(size.width()) && isPowerOfTwo(size.height())))) {
attrs[ 4 ] = GLX_TEXTURE_TARGET_EXT;
attrs[ 5 ] = GLX_TEXTURE_2D_EXT;
} else if (fbcdrawableinfo[ depth ].texture_targets & GLX_TEXTURE_RECTANGLE_BIT_EXT) {
attrs[ 4 ] = GLX_TEXTURE_TARGET_EXT;
attrs[ 5 ] = GLX_TEXTURE_RECTANGLE_EXT;
}
int attrs[] = {
GLX_TEXTURE_FORMAT_EXT, fbcdrawableinfo[ depth ].bind_texture_format,
GLX_MIPMAP_TEXTURE_EXT, fbcdrawableinfo[ depth ].mipmap,
None, None, None
};
// Specifying the texture target explicitly is reported to cause a performance
// regression with R300G (see bug #256654).
if (GLPlatform::instance()->driver() != Driver_R300G) {
if ((fbcdrawableinfo[ depth ].texture_targets & GLX_TEXTURE_2D_BIT_EXT) &&
(GLTexture::NPOTTextureSupported() ||
(isPowerOfTwo(size.width()) && isPowerOfTwo(size.height())))) {
attrs[ 4 ] = GLX_TEXTURE_TARGET_EXT;
attrs[ 5 ] = GLX_TEXTURE_2D_EXT;
} else if (fbcdrawableinfo[ depth ].texture_targets & GLX_TEXTURE_RECTANGLE_BIT_EXT) {
attrs[ 4 ] = GLX_TEXTURE_TARGET_EXT;
attrs[ 5 ] = GLX_TEXTURE_RECTANGLE_EXT;
}
glxpixmap = glXCreatePixmap(display(), fbcdrawableinfo[ depth ].fbconfig, pix, attrs);
#ifdef CHECK_GL_ERROR
checkGLError("TextureLoadTFP1");
#endif
findTarget();
y_inverted = fbcdrawableinfo[ depth ].y_inverted ? true : false;
can_use_mipmaps = fbcdrawableinfo[ depth ].mipmap ? true : false;
glBindTexture(mTarget, mTexture);
#ifdef CHECK_GL_ERROR
checkGLError("TextureLoadTFP2");
#endif
if (!options->glStrictBinding)
glXBindTexImageEXT(display(), glxpixmap, GLX_FRONT_LEFT_EXT, NULL);
}
if (options->glStrictBinding)
// Mark the texture as damaged so it will be updated on the next call to bind()
glXBindTexImageEXT(display(), glxpixmap, GLX_FRONT_LEFT_EXT, NULL);
d->m_glxpixmap = glXCreatePixmap(display(), fbcdrawableinfo[ depth ].fbconfig, pix, attrs);
#ifdef CHECK_GL_ERROR
checkGLError("TextureLoadTFP1");
#endif
findTarget();
d->m_yInverted = fbcdrawableinfo[ depth ].y_inverted ? true : false;
d->m_canUseMipmaps = fbcdrawableinfo[ depth ].mipmap ? true : false;
glBindTexture(d->m_target, d->m_texture);
#ifdef CHECK_GL_ERROR
checkGLError("TextureLoadTFP2");
#endif
glXBindTexImageEXT(display(), d->m_glxpixmap, GLX_FRONT_LEFT_EXT, NULL);
#ifdef CHECK_GL_ERROR
checkGLError("TextureLoad0");
#endif
return true;
}
void SceneOpenGL::Texture::bind()
void SceneOpenGL::TexturePrivate::bind()
{
glEnable(mTarget);
glBindTexture(mTarget, mTexture);
// if one of the GLTexture::load functions is called, the glxpixmap doesn't
// have to exist
if (options->glStrictBinding && glxpixmap) {
glXReleaseTexImageEXT(display(), glxpixmap, GLX_FRONT_LEFT_EXT);
glXBindTexImageEXT(display(), glxpixmap, GLX_FRONT_LEFT_EXT, NULL);
setDirty(); // Mipmaps have to be regenerated after updating the texture
GLTexturePrivate::bind();
if (options->glStrictBinding && m_glxpixmap) {
glXReleaseTexImageEXT(display(), m_glxpixmap, GLX_FRONT_LEFT_EXT);
glXBindTexImageEXT(display(), m_glxpixmap, GLX_FRONT_LEFT_EXT, NULL);
m_hasValidMipmaps = false; // Mipmaps have to be regenerated after updating the texture
}
enableFilter();
if (hasGLVersion(1, 4, 0)) {
@ -686,17 +683,16 @@ void SceneOpenGL::Texture::bind()
}
}
void SceneOpenGL::Texture::unbind()
void SceneOpenGL::TexturePrivate::unbind()
{
if (hasGLVersion(1, 4, 0)) {
glTexEnvf(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, 0.0f);
}
// if one of the GLTexture::load functions is called, the glxpixmap doesn't
// have to exist
if (options->glStrictBinding && glxpixmap) {
glBindTexture(mTarget, mTexture);
glXReleaseTexImageEXT(display(), glxpixmap, GLX_FRONT_LEFT_EXT);
if (options->glStrictBinding && m_glxpixmap) {
glBindTexture(m_target, m_texture);
glXReleaseTexImageEXT(display(), m_glxpixmap, GLX_FRONT_LEFT_EXT);
}
GLTexture::unbind();
GLTexturePrivate::unbind();
}