1435 lines
52 KiB
C++
1435 lines
52 KiB
C++
/********************************************************************
|
|
KWin - the KDE window manager
|
|
This file is part of the KDE project.
|
|
|
|
Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
|
|
|
|
Based on glcompmgr code by Felix Bellaby.
|
|
Using code from Compiz and Beryl.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*********************************************************************/
|
|
|
|
|
|
/*
|
|
This is the OpenGL-based compositing code. It is the primary and most powerful
|
|
compositing backend.
|
|
|
|
Sources and other compositing managers:
|
|
=======================================
|
|
|
|
- http://opengl.org
|
|
- documentation
|
|
- OpenGL Redbook (http://opengl.org/documentation/red_book/ - note it's only version 1.1)
|
|
- GLX docs (http://opengl.org/documentation/specs/glx/glx1.4.pdf)
|
|
- extensions docs (http://www.opengl.org/registry/)
|
|
|
|
- glcompmgr
|
|
- http://lists.freedesktop.org/archives/xorg/2006-July/017006.html ,
|
|
- http://www.mail-archive.com/compiz%40lists.freedesktop.org/msg00023.html
|
|
- simple and easy to understand
|
|
- works even without texture_from_pixmap extension
|
|
- claims to support several different gfx cards
|
|
- compile with something like
|
|
"gcc -Wall glcompmgr-0.5.c `pkg-config --cflags --libs glib-2.0` -lGL -lXcomposite -lXdamage -L/usr/X11R6/lib"
|
|
|
|
- compiz
|
|
- git clone git://anongit.freedesktop.org/git/xorg/app/compiz
|
|
- the ultimate <whatever>
|
|
- glxcompmgr
|
|
- git clone git://anongit.freedesktop.org/git/xorg/app/glxcompgr
|
|
- a rather old version of compiz, but also simpler and as such simpler
|
|
to understand
|
|
|
|
- beryl
|
|
- a fork of Compiz
|
|
- http://beryl-project.org
|
|
- git clone git://anongit.beryl-project.org/beryl/beryl-core (or beryl-plugins etc. ,
|
|
the full list should be at git://anongit.beryl-project.org/beryl/)
|
|
|
|
- libcm (metacity)
|
|
- cvs -d :pserver:anonymous@anoncvs.gnome.org:/cvs/gnome co libcm
|
|
- not much idea about it, the model differs a lot from KWin/Compiz/Beryl
|
|
- does not seem to be very powerful or with that much development going on
|
|
|
|
*/
|
|
|
|
#include "scene_opengl.h"
|
|
#include "kwinglplatform.h"
|
|
|
|
#include <kxerrorhandler.h>
|
|
|
|
// TODO: use <>
|
|
#include "lib/kwinglplatform.h"
|
|
|
|
#include "utils.h"
|
|
#include "client.h"
|
|
#include "deleted.h"
|
|
#include "effects.h"
|
|
|
|
#include <math.h>
|
|
|
|
// 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
|
|
|
|
#ifdef KWIN_HAVE_OPENGL_COMPOSITING
|
|
|
|
#include <X11/extensions/Xcomposite.h>
|
|
|
|
#include <qpainter.h>
|
|
#include <QVector2D>
|
|
#include <QVector4D>
|
|
#include <QMatrix4x4>
|
|
|
|
namespace KWin
|
|
{
|
|
|
|
extern int currentRefreshRate();
|
|
|
|
//****************************************
|
|
// SceneOpenGL
|
|
//****************************************
|
|
|
|
bool SceneOpenGL::db; // destination drawable is double-buffered
|
|
|
|
#ifdef KWIN_HAVE_OPENGLES
|
|
#include "scene_opengl_egl.cpp"
|
|
#else
|
|
#include "scene_opengl_glx.cpp"
|
|
#endif
|
|
|
|
bool SceneOpenGL::initFailed() const
|
|
{
|
|
return !init_ok;
|
|
}
|
|
|
|
bool SceneOpenGL::selectMode()
|
|
{
|
|
if (!initDrawableConfigs())
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
// Test if compositing actually _really_ works, by creating a texture from a testing
|
|
// window, drawing it on the screen, reading the contents back and comparing. This
|
|
// should test whether compositing really works.
|
|
// This function does the whole selfcheck, it can be done also in two parts
|
|
// during actual drawing (to avoid flicker, see selfCheck() call from the ctor).
|
|
bool SceneOpenGL::selfCheck()
|
|
{
|
|
QRegion reg = selfCheckRegion();
|
|
if (wspace->overlayWindow()) {
|
|
// avoid covering the whole screen too soon
|
|
wspace->setOverlayShape(reg);
|
|
wspace->showOverlay();
|
|
}
|
|
selfCheckSetup();
|
|
flushBuffer(PAINT_SCREEN_REGION, reg);
|
|
bool ok = selfCheckFinish();
|
|
if (wspace->overlayWindow())
|
|
wspace->hideOverlay();
|
|
return ok;
|
|
}
|
|
|
|
void SceneOpenGL::paintGenericScreen(int mask, ScreenPaintData data)
|
|
{
|
|
const bool useShader = ShaderManager::instance()->isValid();
|
|
if (mask & PAINT_SCREEN_TRANSFORMED) {
|
|
// apply screen transformations
|
|
QMatrix4x4 screenTransformation;
|
|
screenTransformation.translate(data.xTranslate, data.yTranslate, data.zTranslate);
|
|
if (data.rotation) {
|
|
screenTransformation.translate(data.rotation->xRotationPoint, data.rotation->yRotationPoint, data.rotation->zRotationPoint);
|
|
// translate to rotation point, rotate, translate back
|
|
qreal xAxis = 0.0;
|
|
qreal yAxis = 0.0;
|
|
qreal zAxis = 0.0;
|
|
switch(data.rotation->axis) {
|
|
case RotationData::XAxis:
|
|
xAxis = 1.0;
|
|
break;
|
|
case RotationData::YAxis:
|
|
yAxis = 1.0;
|
|
break;
|
|
case RotationData::ZAxis:
|
|
zAxis = 1.0;
|
|
break;
|
|
}
|
|
screenTransformation.rotate(data.rotation->angle, xAxis, yAxis, zAxis);
|
|
screenTransformation.translate(-data.rotation->xRotationPoint, -data.rotation->yRotationPoint, -data.rotation->zRotationPoint);
|
|
}
|
|
screenTransformation.scale(data.xScale, data.yScale, data.zScale);
|
|
if (useShader) {
|
|
GLShader *shader = ShaderManager::instance()->pushShader(ShaderManager::GenericShader);
|
|
shader->setUniform("screenTransformation", screenTransformation);
|
|
} else {
|
|
pushMatrix(screenTransformation);
|
|
}
|
|
} else if (useShader && ((mask & PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS) || (mask & PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_WITHOUT_FULL_REPAINTS))) {
|
|
GLShader *shader = ShaderManager::instance()->pushShader(ShaderManager::GenericShader);
|
|
shader->setUniform("screenTransformation", QMatrix4x4());
|
|
}
|
|
Scene::paintGenericScreen(mask, data);
|
|
if (mask & PAINT_SCREEN_TRANSFORMED) {
|
|
if (useShader) {
|
|
ShaderManager::instance()->popShader();
|
|
} else {
|
|
popMatrix();
|
|
}
|
|
} else if (useShader && ((mask & PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS) ||
|
|
(mask & PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_WITHOUT_FULL_REPAINTS))) {
|
|
ShaderManager::instance()->popShader();
|
|
}
|
|
}
|
|
|
|
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();
|
|
}
|
|
GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
|
|
vbo->reset();
|
|
vbo->setUseColor(true);
|
|
vbo->setData(verts.count() / 2, 2, verts.data(), NULL);
|
|
const bool useShader = ShaderManager::instance()->isValid();
|
|
if (useShader) {
|
|
GLShader *shader = ShaderManager::instance()->pushShader(ShaderManager::ColorShader);
|
|
shader->setUniform("offset", QVector2D(0, 0));
|
|
}
|
|
vbo->render(GL_TRIANGLES);
|
|
if (useShader) {
|
|
ShaderManager::instance()->popShader();
|
|
}
|
|
}
|
|
|
|
void SceneOpenGL::windowAdded(Toplevel* c)
|
|
{
|
|
assert(!windows.contains(c));
|
|
windows[ c ] = new Window(c);
|
|
c->effectWindow()->setSceneWindow(windows[ c ]);
|
|
}
|
|
|
|
void SceneOpenGL::windowClosed(Toplevel* c, Deleted* deleted)
|
|
{
|
|
assert(windows.contains(c));
|
|
if (deleted != NULL) {
|
|
// replace c with deleted
|
|
Window* w = windows.take(c);
|
|
w->updateToplevel(deleted);
|
|
windows[ deleted ] = w;
|
|
} else {
|
|
delete windows.take(c);
|
|
c->effectWindow()->setSceneWindow(NULL);
|
|
}
|
|
}
|
|
|
|
void SceneOpenGL::windowDeleted(Deleted* c)
|
|
{
|
|
assert(windows.contains(c));
|
|
delete windows.take(c);
|
|
c->effectWindow()->setSceneWindow(NULL);
|
|
}
|
|
|
|
void SceneOpenGL::windowGeometryShapeChanged(Toplevel* c)
|
|
{
|
|
if (!windows.contains(c)) // this is ok, shape is not valid
|
|
return; // by default
|
|
Window* w = windows[ c ];
|
|
w->discardShape();
|
|
w->checkTextureSize();
|
|
}
|
|
|
|
void SceneOpenGL::windowOpacityChanged(Toplevel*)
|
|
{
|
|
#if 0 // not really needed, windows are painted on every repaint
|
|
// and opacity is used when applying texture, not when
|
|
// creating it
|
|
if (!windows.contains(c)) // this is ok, texture is created
|
|
return; // on demand
|
|
Window* w = windows[ c ];
|
|
w->discardTexture();
|
|
#endif
|
|
}
|
|
|
|
//****************************************
|
|
// SceneOpenGL::Texture
|
|
//****************************************
|
|
|
|
SceneOpenGL::Texture::Texture() : GLTexture()
|
|
{
|
|
init();
|
|
}
|
|
|
|
SceneOpenGL::Texture::Texture(const Pixmap& pix, const QSize& size, int depth) : GLTexture()
|
|
{
|
|
init();
|
|
load(pix, size, depth);
|
|
}
|
|
|
|
SceneOpenGL::Texture::~Texture()
|
|
{
|
|
discard();
|
|
}
|
|
|
|
void SceneOpenGL::Texture::createTexture()
|
|
{
|
|
glGenTextures(1, &mTexture);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
bool SceneOpenGL::Texture::load(const Pixmap& pix, const QSize& size,
|
|
int depth)
|
|
{
|
|
return load(pix, size, depth,
|
|
QRegion(0, 0, size.width(), size.height()));
|
|
}
|
|
|
|
bool SceneOpenGL::Texture::load(const QImage& image, GLenum target)
|
|
{
|
|
if (image.isNull())
|
|
return false;
|
|
return load(QPixmap::fromImage(image), target);
|
|
}
|
|
|
|
bool SceneOpenGL::Texture::load(const QPixmap& pixmap, GLenum target)
|
|
{
|
|
Q_UNUSED(target); // SceneOpenGL::Texture::findTarget() detects the target
|
|
if (pixmap.isNull())
|
|
return false;
|
|
return load(pixmap.handle(), pixmap.size(), pixmap.depth());
|
|
}
|
|
|
|
//****************************************
|
|
// SceneOpenGL::Window
|
|
//****************************************
|
|
|
|
SceneOpenGL::Window::Window(Toplevel* c)
|
|
: Scene::Window(c)
|
|
, texture()
|
|
, topTexture()
|
|
, leftTexture()
|
|
, rightTexture()
|
|
, bottomTexture()
|
|
{
|
|
}
|
|
|
|
SceneOpenGL::Window::~Window()
|
|
{
|
|
discardTexture();
|
|
}
|
|
|
|
// Bind the window pixmap to an OpenGL texture.
|
|
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());
|
|
return true;
|
|
}
|
|
#endif
|
|
// Get the pixmap with the window contents
|
|
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
|
|
kDebug(1212) << "Failed to bind window";
|
|
return success;
|
|
}
|
|
|
|
void SceneOpenGL::Window::discardTexture()
|
|
{
|
|
texture.discard();
|
|
topTexture.discard();
|
|
leftTexture.discard();
|
|
rightTexture.discard();
|
|
bottomTexture.discard();
|
|
}
|
|
|
|
// This call is used in SceneOpenGL::windowGeometryShapeChanged(),
|
|
// which originally called discardTexture(), however this was causing performance
|
|
// problems with the launch feedback icon - large number of texture rebinds.
|
|
// Since the launch feedback icon does not resize, only changes shape, it
|
|
// is not necessary to rebind the texture (with no strict binding), therefore
|
|
// discard the texture only if size changes.
|
|
void SceneOpenGL::Window::checkTextureSize()
|
|
{
|
|
if (texture.size() != size())
|
|
discardTexture();
|
|
}
|
|
|
|
// when the window's composite pixmap is discarded, undo binding it to the texture
|
|
void SceneOpenGL::Window::pixmapDiscarded()
|
|
{
|
|
texture.release();
|
|
}
|
|
|
|
// paint the window
|
|
void SceneOpenGL::Window::performPaint(int mask, QRegion region, WindowPaintData data)
|
|
{
|
|
// check if there is something to paint (e.g. don't paint if the window
|
|
// is only opaque and only PAINT_WINDOW_TRANSLUCENT is requested)
|
|
/* HACK: It seems this causes painting glitches, disable temporarily
|
|
bool opaque = isOpaque() && data.opacity == 1.0;
|
|
if (( mask & PAINT_WINDOW_OPAQUE ) ^ ( mask & PAINT_WINDOW_TRANSLUCENT ))
|
|
{ // We are only painting either opaque OR translucent windows, not both
|
|
if ( mask & PAINT_WINDOW_OPAQUE && !opaque )
|
|
return; // Only painting opaque and window is translucent
|
|
if ( mask & PAINT_WINDOW_TRANSLUCENT && opaque )
|
|
return; // Only painting translucent and window is opaque
|
|
}*/
|
|
// paint only requested areas
|
|
if (region != infiniteRegion()) // avoid integer overflow
|
|
region.translate(-x(), -y());
|
|
if (region.isEmpty())
|
|
return;
|
|
if (!bindTexture())
|
|
return;
|
|
// set texture filter
|
|
if (options->glSmoothScale != 0) { // default to yes
|
|
if (mask & PAINT_WINDOW_TRANSFORMED)
|
|
filter = ImageFilterGood;
|
|
else if (mask & PAINT_SCREEN_TRANSFORMED)
|
|
filter = ImageFilterGood;
|
|
else
|
|
filter = ImageFilterFast;
|
|
} else
|
|
filter = ImageFilterFast;
|
|
if (filter == ImageFilterGood)
|
|
texture.setFilter(GL_LINEAR);
|
|
else
|
|
texture.setFilter(GL_NEAREST);
|
|
// do required transformations
|
|
int x = toplevel->x();
|
|
int y = toplevel->y();
|
|
double z = 0.0;
|
|
bool sceneShader = false;
|
|
if (!data.shader && ShaderManager::instance()->isValid()) {
|
|
// set the shader for uniform initialising in paint decoration
|
|
if ((mask & PAINT_WINDOW_TRANSFORMED) || (mask & PAINT_SCREEN_TRANSFORMED)) {
|
|
data.shader = ShaderManager::instance()->pushShader(ShaderManager::GenericShader);
|
|
} else {
|
|
data.shader = ShaderManager::instance()->pushShader(ShaderManager::SimpleShader);
|
|
data.shader->setUniform("offset", QVector2D(x, y));
|
|
}
|
|
sceneShader = true;
|
|
}
|
|
QMatrix4x4 windowTransformation;
|
|
windowTransformation.translate(x, y);
|
|
if ((mask & PAINT_WINDOW_TRANSFORMED) || (mask & PAINT_SCREEN_TRANSFORMED)) {
|
|
windowTransformation.translate(data.xTranslate, data.yTranslate, data.zTranslate);
|
|
if ((mask & PAINT_WINDOW_TRANSFORMED) && (data.xScale != 1 || data.yScale != 1 || data.zScale != 1)) {
|
|
windowTransformation.scale(data.xScale, data.yScale, data.zScale);
|
|
}
|
|
if ((mask & PAINT_WINDOW_TRANSFORMED) && data.rotation) {
|
|
windowTransformation.translate(data.rotation->xRotationPoint, data.rotation->yRotationPoint, data.rotation->zRotationPoint);
|
|
qreal xAxis = 0.0;
|
|
qreal yAxis = 0.0;
|
|
qreal zAxis = 0.0;
|
|
switch(data.rotation->axis) {
|
|
case RotationData::XAxis:
|
|
xAxis = 1.0;
|
|
break;
|
|
case RotationData::YAxis:
|
|
yAxis = 1.0;
|
|
break;
|
|
case RotationData::ZAxis:
|
|
zAxis = 1.0;
|
|
break;
|
|
}
|
|
windowTransformation.rotate(data.rotation->angle, xAxis, yAxis, zAxis);
|
|
windowTransformation.translate(-data.rotation->xRotationPoint, -data.rotation->yRotationPoint, -data.rotation->zRotationPoint);
|
|
}
|
|
if (data.shader) {
|
|
data.shader->setUniform("windowTransformation", windowTransformation);
|
|
}
|
|
}
|
|
if (!sceneShader) {
|
|
pushMatrix(windowTransformation);
|
|
}
|
|
region.translate(toplevel->x(), toplevel->y()); // Back to screen coords
|
|
|
|
WindowQuadList decoration = data.quads.select(WindowQuadDecoration);
|
|
|
|
GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
|
|
vbo->reset();
|
|
|
|
// decorations
|
|
Client *client = dynamic_cast<Client*>(toplevel);
|
|
Deleted *deleted = dynamic_cast<Deleted*>(toplevel);
|
|
if (client || deleted) {
|
|
bool noBorder = true;
|
|
bool updateDeco = false;
|
|
const QPixmap *left = NULL;
|
|
const QPixmap *top = NULL;
|
|
const QPixmap *right = NULL;
|
|
const QPixmap *bottom = NULL;
|
|
QRect topRect, leftRect, rightRect, bottomRect;
|
|
if (client && !client->noBorder()) {
|
|
noBorder = false;
|
|
updateDeco = client->decorationPixmapRequiresRepaint();
|
|
client->ensureDecorationPixmapsPainted();
|
|
|
|
client->layoutDecorationRects(leftRect, topRect, rightRect, bottomRect, Client::WindowRelative);
|
|
|
|
left = client->leftDecoPixmap();
|
|
top = client->topDecoPixmap();
|
|
right = client->rightDecoPixmap();
|
|
bottom = client->bottomDecoPixmap();
|
|
}
|
|
if (deleted && !deleted->noBorder()) {
|
|
noBorder = false;
|
|
left = deleted->leftDecoPixmap();
|
|
top = deleted->topDecoPixmap();
|
|
right = deleted->rightDecoPixmap();
|
|
bottom = deleted->bottomDecoPixmap();
|
|
deleted->layoutDecorationRects(leftRect, topRect, rightRect, bottomRect);
|
|
}
|
|
if (!noBorder) {
|
|
WindowQuadList topList, leftList, rightList, bottomList;
|
|
|
|
foreach (const WindowQuad & quad, decoration) {
|
|
if (topRect.contains(QPoint(quad.originalLeft(), quad.originalTop()))) {
|
|
topList.append(quad);
|
|
continue;
|
|
}
|
|
if (bottomRect.contains(QPoint(quad.originalLeft(), quad.originalTop()))) {
|
|
bottomList.append(quad);
|
|
continue;
|
|
}
|
|
if (leftRect.contains(QPoint(quad.originalLeft(), quad.originalTop()))) {
|
|
leftList.append(quad);
|
|
continue;
|
|
}
|
|
if (rightRect.contains(QPoint(quad.originalLeft(), quad.originalTop()))) {
|
|
rightList.append(quad);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
paintDecoration(top, DecorationTop, region, topRect, data, topList, updateDeco);
|
|
paintDecoration(left, DecorationLeft, region, leftRect, data, leftList, updateDeco);
|
|
paintDecoration(right, DecorationRight, region, rightRect, data, rightList, updateDeco);
|
|
paintDecoration(bottom, DecorationBottom, region, bottomRect, data, bottomList, updateDeco);
|
|
}
|
|
}
|
|
|
|
// paint the content
|
|
if (!(mask & PAINT_DECORATION_ONLY)) {
|
|
texture.bind();
|
|
texture.enableUnnormalizedTexCoords();
|
|
prepareStates(Content, data.opacity * data.contents_opacity, data.brightness, data.saturation, data.shader);
|
|
renderQuads(mask, region, data.quads.select(WindowQuadContents));
|
|
restoreStates(Content, data.opacity * data.contents_opacity, data.brightness, data.saturation, data.shader);
|
|
texture.disableUnnormalizedTexCoords();
|
|
texture.unbind();
|
|
#ifndef KWIN_HAVE_OPENGLES
|
|
if (static_cast<SceneOpenGL*>(scene)->debug) {
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
|
|
renderQuads(mask, region, data.quads.select(WindowQuadContents));
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if (sceneShader) {
|
|
ShaderManager::instance()->popShader();
|
|
data.shader = NULL;
|
|
} else {
|
|
popMatrix();
|
|
}
|
|
}
|
|
|
|
void SceneOpenGL::Window::paintDecoration(const QPixmap* decoration, TextureType decorationType, const QRegion& region, const QRect& rect, const WindowPaintData& data, const WindowQuadList& quads, bool updateDeco)
|
|
{
|
|
if (quads.isEmpty())
|
|
return;
|
|
SceneOpenGL::Texture* decorationTexture;
|
|
switch(decorationType) {
|
|
case DecorationTop:
|
|
decorationTexture = &topTexture;
|
|
break;
|
|
case DecorationLeft:
|
|
decorationTexture = &leftTexture;
|
|
break;
|
|
case DecorationRight:
|
|
decorationTexture = &rightTexture;
|
|
break;
|
|
case DecorationBottom:
|
|
decorationTexture = &bottomTexture;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
if (decorationTexture->texture() != None && !updateDeco) {
|
|
// texture doesn't need updating, just bind it
|
|
glBindTexture(decorationTexture->target(), decorationTexture->texture());
|
|
} else if (!decoration->isNull()) {
|
|
bool success = decorationTexture->load(decoration->handle(), decoration->size(), decoration->depth());
|
|
if (!success) {
|
|
kDebug(1212) << "Failed to bind decoartion";
|
|
return;
|
|
}
|
|
} else
|
|
return;
|
|
if (filter == ImageFilterGood)
|
|
decorationTexture->setFilter(GL_LINEAR);
|
|
else
|
|
decorationTexture->setFilter(GL_NEAREST);
|
|
decorationTexture->setWrapMode(GL_CLAMP_TO_EDGE);
|
|
decorationTexture->bind();
|
|
|
|
prepareStates(decorationType, data.opacity * data.decoration_opacity, data.brightness, data.saturation, data.shader);
|
|
makeDecorationArrays(quads, rect);
|
|
if (data.shader) {
|
|
data.shader->setUniform("textureWidth", 1.0f);
|
|
data.shader->setUniform("textureHeight", 1.0f);
|
|
}
|
|
GLVertexBuffer::streamingBuffer()->render(region, GL_TRIANGLES);
|
|
restoreStates(decorationType, data.opacity * data.decoration_opacity, data.brightness, data.saturation, data.shader);
|
|
decorationTexture->unbind();
|
|
#ifndef KWIN_HAVE_OPENGLES
|
|
if (static_cast<SceneOpenGL*>(scene)->debug) {
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
|
|
GLVertexBuffer::streamingBuffer()->render(region, GL_TRIANGLES);
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void SceneOpenGL::Window::makeDecorationArrays(const WindowQuadList& quads, const QRect& rect) const
|
|
{
|
|
QVector<float> vertices;
|
|
QVector<float> texcoords;
|
|
vertices.reserve(quads.count() * 6 * 2);
|
|
texcoords.reserve(quads.count() * 6 * 2);
|
|
float width = rect.width();
|
|
float height = rect.height();
|
|
foreach (const WindowQuad & quad, quads) {
|
|
vertices << quad[ 1 ].x();
|
|
vertices << quad[ 1 ].y();
|
|
vertices << quad[ 0 ].x();
|
|
vertices << quad[ 0 ].y();
|
|
vertices << quad[ 3 ].x();
|
|
vertices << quad[ 3 ].y();
|
|
vertices << quad[ 3 ].x();
|
|
vertices << quad[ 3 ].y();
|
|
vertices << quad[ 2 ].x();
|
|
vertices << quad[ 2 ].y();
|
|
vertices << quad[ 1 ].x();
|
|
vertices << quad[ 1 ].y();
|
|
|
|
texcoords << (float)(quad.originalRight() - rect.x()) / width;
|
|
texcoords << (float)(quad.originalTop() - rect.y()) / height;
|
|
texcoords << (float)(quad.originalLeft() - rect.x()) / width;
|
|
texcoords << (float)(quad.originalTop() - rect.y()) / height;
|
|
texcoords << (float)(quad.originalLeft() - rect.x()) / width;
|
|
texcoords << (float)(quad.originalBottom() - rect.y()) / height;
|
|
texcoords << (float)(quad.originalLeft() - rect.x()) / width;
|
|
texcoords << (float)(quad.originalBottom() - rect.y()) / height;
|
|
texcoords << (float)(quad.originalRight() - rect.x()) / width;
|
|
texcoords << (float)(quad.originalBottom() - rect.y()) / height;
|
|
texcoords << (float)(quad.originalRight() - rect.x()) / width;
|
|
texcoords << (float)(quad.originalTop() - rect.y()) / height;
|
|
}
|
|
GLVertexBuffer::streamingBuffer()->setData(quads.count() * 6, 2, vertices.data(), texcoords.data());
|
|
}
|
|
|
|
void SceneOpenGL::Window::renderQuads(int, const QRegion& region, const WindowQuadList& quads)
|
|
{
|
|
if (quads.isEmpty())
|
|
return;
|
|
// Render geometry
|
|
float* vertices;
|
|
float* texcoords;
|
|
quads.makeArrays(&vertices, &texcoords);
|
|
GLVertexBuffer::streamingBuffer()->setData(quads.count() * 6, 2, vertices, texcoords);
|
|
GLVertexBuffer::streamingBuffer()->render(region, GL_TRIANGLES);
|
|
delete[] vertices;
|
|
delete[] texcoords;
|
|
}
|
|
|
|
void SceneOpenGL::Window::prepareStates(TextureType type, double opacity, double brightness, double saturation, GLShader* shader)
|
|
{
|
|
if (shader)
|
|
prepareShaderRenderStates(type, opacity, brightness, saturation, shader);
|
|
else
|
|
prepareRenderStates(type, opacity, brightness, saturation);
|
|
}
|
|
|
|
void SceneOpenGL::Window::prepareShaderRenderStates(TextureType type, double opacity, double brightness, double saturation, GLShader* shader)
|
|
{
|
|
// setup blending of transparent windows
|
|
#ifndef KWIN_HAVE_OPENGLES
|
|
glPushAttrib(GL_ENABLE_BIT);
|
|
#endif
|
|
bool opaque = isOpaque() && opacity == 1.0;
|
|
bool alpha = toplevel->hasAlpha() || type != Content;
|
|
if (type != Content)
|
|
opaque = false;
|
|
if (!opaque) {
|
|
glEnable(GL_BLEND);
|
|
if (alpha) {
|
|
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
|
|
} else {
|
|
glBlendColor((float)opacity, (float)opacity, (float)opacity, (float)opacity);
|
|
glBlendFunc(GL_ONE, GL_ONE_MINUS_CONSTANT_ALPHA);
|
|
}
|
|
}
|
|
shader->setUniform("opacity", (float)opacity);
|
|
shader->setUniform("saturation", (float)saturation);
|
|
shader->setUniform("brightness", (float)brightness);
|
|
shader->setUniform("u_forceAlpha", opaque ? 1 : 0);
|
|
|
|
// setting texture width and heiht stored in shader
|
|
// only set if it is set by an effect that is not negative
|
|
float texw = shader->textureWidth();
|
|
if (texw >= 0.0f)
|
|
shader->setUniform("textureWidth", texw);
|
|
else
|
|
shader->setUniform("textureWidth", (float)toplevel->width());
|
|
float texh = shader->textureHeight();
|
|
if (texh >= 0.0f)
|
|
shader->setUniform("textureHeight", texh);
|
|
else
|
|
shader->setUniform("textureHeight", (float)toplevel->height());
|
|
}
|
|
|
|
void SceneOpenGL::Window::prepareRenderStates(TextureType type, double opacity, double brightness, double saturation)
|
|
{
|
|
#ifdef KWIN_HAVE_OPENGLES
|
|
Q_UNUSED(type)
|
|
Q_UNUSED(opacity)
|
|
Q_UNUSED(brightness)
|
|
Q_UNUSED(saturation)
|
|
#else
|
|
Texture* tex;
|
|
bool alpha = false;
|
|
bool opaque = true;
|
|
switch(type) {
|
|
case Content:
|
|
tex = &texture;
|
|
alpha = toplevel->hasAlpha();
|
|
opaque = isOpaque() && opacity == 1.0;
|
|
break;
|
|
case DecorationTop:
|
|
tex = &topTexture;
|
|
alpha = true;
|
|
opaque = false;
|
|
break;
|
|
case DecorationLeft:
|
|
tex = &leftTexture;
|
|
alpha = true;
|
|
opaque = false;
|
|
break;
|
|
case DecorationRight:
|
|
tex = &rightTexture;
|
|
alpha = true;
|
|
opaque = false;
|
|
break;
|
|
case DecorationBottom:
|
|
tex = &bottomTexture;
|
|
alpha = true;
|
|
opaque = false;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
// setup blending of transparent windows
|
|
glPushAttrib(GL_ENABLE_BIT);
|
|
if (!opaque) {
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
|
|
}
|
|
if (saturation != 1.0 && tex->saturationSupported()) {
|
|
// First we need to get the color from [0; 1] range to [0.5; 1] range
|
|
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);
|
|
const float scale_constant[] = { 1.0, 1.0, 1.0, 0.5};
|
|
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, scale_constant);
|
|
tex->bind();
|
|
|
|
// 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
|
|
glActiveTexture(GL_TEXTURE1);
|
|
float saturation_constant[] = { 0.5 + 0.5 * 0.30, 0.5 + 0.5 * 0.59, 0.5 + 0.5 * 0.11, saturation };
|
|
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);
|
|
tex->bind();
|
|
|
|
// Finally we need to interpolate between the original image and the
|
|
// greyscale image to get wanted level of saturation
|
|
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);
|
|
// Also replace alpha by primary color's alpha here
|
|
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);
|
|
// And make primary color contain the wanted opacity
|
|
glColor4f(opacity, opacity, opacity, opacity);
|
|
tex->bind();
|
|
|
|
if (alpha || brightness != 1.0f) {
|
|
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);
|
|
// The color has to be multiplied by both opacity and brightness
|
|
float opacityByBrightness = opacity * brightness;
|
|
glColor4f(opacityByBrightness, opacityByBrightness, opacityByBrightness, opacity);
|
|
if (alpha) {
|
|
// Multiply original texture's alpha by our opacity
|
|
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 {
|
|
// Alpha will be taken from previous stage
|
|
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);
|
|
}
|
|
tex->bind();
|
|
}
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
} else if (opacity != 1.0 || brightness != 1.0) {
|
|
// the window is additionally configured to have its opacity adjusted,
|
|
// do it
|
|
float opacityByBrightness = opacity * brightness;
|
|
if (alpha) {
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
|
glColor4f(opacityByBrightness, opacityByBrightness, opacityByBrightness,
|
|
opacity);
|
|
} else {
|
|
// Multiply color by brightness and replace alpha by opacity
|
|
float constant[] = { opacityByBrightness, opacityByBrightness, opacityByBrightness, opacity };
|
|
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);
|
|
}
|
|
} else if (!alpha && opaque) {
|
|
float constant[] = { 1.0, 1.0, 1.0, 1.0 };
|
|
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);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void SceneOpenGL::Window::restoreStates(TextureType type, double opacity, double brightness, double saturation, GLShader* shader)
|
|
{
|
|
if (shader)
|
|
restoreShaderRenderStates(type, opacity, brightness, saturation, shader);
|
|
else
|
|
restoreRenderStates(type, opacity, brightness, saturation);
|
|
}
|
|
|
|
void SceneOpenGL::Window::restoreShaderRenderStates(TextureType type, double opacity, double brightness, double saturation, GLShader* shader)
|
|
{
|
|
Q_UNUSED(brightness);
|
|
Q_UNUSED(saturation);
|
|
Q_UNUSED(shader);
|
|
bool opaque = isOpaque() && opacity == 1.0;
|
|
if (type != Content)
|
|
opaque = false;
|
|
if (!opaque) {
|
|
glDisable(GL_BLEND);
|
|
}
|
|
ShaderManager::instance()->getBoundShader()->setUniform("u_forceAlpha", 0);
|
|
#ifndef KWIN_HAVE_OPENGLES
|
|
glPopAttrib(); // ENABLE_BIT
|
|
#endif
|
|
}
|
|
|
|
void SceneOpenGL::Window::restoreRenderStates(TextureType type, double opacity, double brightness, double saturation)
|
|
{
|
|
#ifdef KWIN_HAVE_OPENGLES
|
|
Q_UNUSED(type)
|
|
Q_UNUSED(opacity)
|
|
Q_UNUSED(brightness)
|
|
Q_UNUSED(saturation)
|
|
#else
|
|
Texture* tex;
|
|
switch(type) {
|
|
case Content:
|
|
tex = &texture;
|
|
break;
|
|
case DecorationTop:
|
|
tex = &topTexture;
|
|
break;
|
|
case DecorationLeft:
|
|
tex = &leftTexture;
|
|
break;
|
|
case DecorationRight:
|
|
tex = &rightTexture;
|
|
break;
|
|
case DecorationBottom:
|
|
tex = &bottomTexture;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
if (opacity != 1.0 || saturation != 1.0 || brightness != 1.0f) {
|
|
if (saturation != 1.0 && tex->saturationSupported()) {
|
|
glActiveTexture(GL_TEXTURE3);
|
|
glDisable(tex->target());
|
|
glActiveTexture(GL_TEXTURE2);
|
|
glDisable(tex->target());
|
|
glActiveTexture(GL_TEXTURE1);
|
|
glDisable(tex->target());
|
|
glActiveTexture(GL_TEXTURE0);
|
|
}
|
|
}
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
glColor4f(0, 0, 0, 0);
|
|
|
|
glPopAttrib(); // ENABLE_BIT
|
|
#endif
|
|
}
|
|
|
|
//****************************************
|
|
// SceneOpenGL::EffectFrame
|
|
//****************************************
|
|
|
|
SceneOpenGL::Texture* SceneOpenGL::EffectFrame::m_unstyledTexture = NULL;
|
|
QPixmap* SceneOpenGL::EffectFrame::m_unstyledPixmap = NULL;
|
|
|
|
SceneOpenGL::EffectFrame::EffectFrame(EffectFrameImpl* frame)
|
|
: 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)
|
|
{
|
|
if (m_effectFrame->style() == EffectFrameUnstyled && !m_unstyledTexture) {
|
|
updateUnstyledTexture();
|
|
}
|
|
}
|
|
|
|
SceneOpenGL::EffectFrame::~EffectFrame()
|
|
{
|
|
delete m_texture;
|
|
delete m_textTexture;
|
|
delete m_textPixmap;
|
|
delete m_oldTextTexture;
|
|
delete m_iconTexture;
|
|
delete m_oldIconTexture;
|
|
delete m_selectionTexture;
|
|
delete m_unstyledVBO;
|
|
}
|
|
|
|
void SceneOpenGL::EffectFrame::free()
|
|
{
|
|
delete m_texture;
|
|
m_texture = NULL;
|
|
delete m_textTexture;
|
|
m_textTexture = NULL;
|
|
delete m_textPixmap;
|
|
m_textPixmap = NULL;
|
|
delete m_iconTexture;
|
|
m_iconTexture = NULL;
|
|
delete m_selectionTexture;
|
|
m_selectionTexture = NULL;
|
|
delete m_unstyledVBO;
|
|
m_unstyledVBO = NULL;
|
|
delete m_oldIconTexture;
|
|
m_oldIconTexture = NULL;
|
|
delete m_oldTextTexture;
|
|
m_oldTextTexture = NULL;
|
|
}
|
|
|
|
void SceneOpenGL::EffectFrame::freeIconFrame()
|
|
{
|
|
delete m_iconTexture;
|
|
m_iconTexture = NULL;
|
|
}
|
|
|
|
void SceneOpenGL::EffectFrame::freeTextFrame()
|
|
{
|
|
delete m_textTexture;
|
|
m_textTexture = NULL;
|
|
delete m_textPixmap;
|
|
m_textPixmap = NULL;
|
|
}
|
|
|
|
void SceneOpenGL::EffectFrame::freeSelection()
|
|
{
|
|
delete m_selectionTexture;
|
|
m_selectionTexture = NULL;
|
|
}
|
|
|
|
void SceneOpenGL::EffectFrame::crossFadeIcon()
|
|
{
|
|
delete m_oldIconTexture;
|
|
m_oldIconTexture = m_iconTexture;
|
|
m_iconTexture = NULL;
|
|
}
|
|
|
|
void SceneOpenGL::EffectFrame::crossFadeText()
|
|
{
|
|
delete m_oldTextTexture;
|
|
m_oldTextTexture = m_textTexture;
|
|
m_textTexture = NULL;
|
|
}
|
|
|
|
void SceneOpenGL::EffectFrame::render(QRegion region, double opacity, double frameOpacity)
|
|
{
|
|
if (m_effectFrame->geometry().isEmpty())
|
|
return; // Nothing to display
|
|
|
|
region = infiniteRegion(); // TODO: Old region doesn't seem to work with OpenGL
|
|
|
|
GLShader* shader = m_effectFrame->shader();
|
|
bool sceneShader = false;
|
|
if (!shader && ShaderManager::instance()->isValid()) {
|
|
shader = ShaderManager::instance()->pushShader(ShaderManager::SimpleShader);
|
|
sceneShader = true;
|
|
} else if (shader) {
|
|
ShaderManager::instance()->pushShader(shader);
|
|
}
|
|
|
|
if (shader) {
|
|
if (sceneShader)
|
|
shader->setUniform("offset", QVector2D(0, 0));
|
|
shader->setUniform("saturation", 1.0f);
|
|
shader->setUniform("brightness", 1.0f);
|
|
shader->setUniform("u_forceAlpha", 0);
|
|
|
|
shader->setUniform("textureWidth", 1.0f);
|
|
shader->setUniform("textureHeight", 1.0f);
|
|
}
|
|
|
|
#ifndef KWIN_HAVE_OPENGLES
|
|
glPushAttrib(GL_CURRENT_BIT | GL_ENABLE_BIT | GL_TEXTURE_BIT);
|
|
#endif
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
#ifndef KWIN_HAVE_OPENGLES
|
|
if (!shader)
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
|
|
|
// TODO: drop the push matrix
|
|
glPushMatrix();
|
|
#endif
|
|
|
|
// Render the actual frame
|
|
if (m_effectFrame->style() == EffectFrameUnstyled) {
|
|
if (!m_unstyledVBO) {
|
|
m_unstyledVBO = new GLVertexBuffer(GLVertexBuffer::Static);
|
|
QRect area = m_effectFrame->geometry();
|
|
area.moveTo(0, 0);
|
|
area.adjust(-5, -5, 5, 5);
|
|
|
|
const int roundness = 5;
|
|
QVector<float> verts, texCoords;
|
|
verts.reserve(84);
|
|
texCoords.reserve(84);
|
|
|
|
// 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;
|
|
|
|
m_unstyledVBO->setData(verts.count() / 2, 2, verts.data(), texCoords.data());
|
|
}
|
|
|
|
if (shader)
|
|
shader->setUniform("opacity", (float)(opacity * frameOpacity));
|
|
#ifndef KWIN_HAVE_OPENGLES
|
|
else
|
|
glColor4f(0.0, 0.0, 0.0, opacity * frameOpacity);
|
|
#endif
|
|
|
|
m_unstyledTexture->bind();
|
|
const QPoint pt = m_effectFrame->geometry().topLeft();
|
|
if (sceneShader) {
|
|
shader->setUniform("offset", QVector2D(pt.x(), pt.y()));
|
|
} else {
|
|
QMatrix4x4 translation;
|
|
translation.translate(pt.x(), pt.y());
|
|
if (shader) {
|
|
shader->setUniform("windowTransformation", translation);
|
|
} else {
|
|
pushMatrix(translation);
|
|
}
|
|
}
|
|
m_unstyledVBO->render(region, GL_TRIANGLES);
|
|
if (!sceneShader) {
|
|
if (shader) {
|
|
shader->setUniform("windowTransformation", QMatrix4x4());
|
|
} else {
|
|
popMatrix();
|
|
}
|
|
}
|
|
m_unstyledTexture->unbind();
|
|
} else if (m_effectFrame->style() == EffectFrameStyled) {
|
|
if (!m_texture) // Lazy creation
|
|
updateTexture();
|
|
|
|
if (shader)
|
|
shader->setUniform("opacity", (float)(opacity * frameOpacity));
|
|
#ifndef KWIN_HAVE_OPENGLES
|
|
else
|
|
glColor4f(1.0, 1.0, 1.0, opacity * frameOpacity);
|
|
#endif
|
|
m_texture->bind();
|
|
qreal left, top, right, bottom;
|
|
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));
|
|
m_texture->unbind();
|
|
|
|
if (!m_effectFrame->selection().isNull()) {
|
|
if (!m_selectionTexture) { // Lazy creation
|
|
QPixmap pixmap = m_effectFrame->selectionFrame().framePixmap();
|
|
m_selectionTexture = new Texture(pixmap.handle(), pixmap.size(), pixmap.depth());
|
|
m_selectionTexture->setYInverted(true);
|
|
}
|
|
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);
|
|
}
|
|
}
|
|
|
|
// Render icon
|
|
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) {
|
|
if (shader)
|
|
shader->setUniform("opacity", (float)opacity *(1.0f - (float)m_effectFrame->crossFadeProgress()));
|
|
#ifndef KWIN_HAVE_OPENGLES
|
|
else
|
|
glColor4f(1.0, 1.0, 1.0, opacity *(1.0 - m_effectFrame->crossFadeProgress()));
|
|
#endif
|
|
|
|
m_oldIconTexture->bind();
|
|
m_oldIconTexture->render(region, QRect(topLeft, m_effectFrame->iconSize()));
|
|
m_oldIconTexture->unbind();
|
|
if (shader)
|
|
shader->setUniform("opacity", (float)opacity *(float)m_effectFrame->crossFadeProgress());
|
|
#ifndef KWIN_HAVE_OPENGLES
|
|
else
|
|
glColor4f(1.0, 1.0, 1.0, opacity * m_effectFrame->crossFadeProgress());
|
|
#endif
|
|
} else {
|
|
if (shader)
|
|
shader->setUniform("opacity", (float)opacity);
|
|
#ifndef KWIN_HAVE_OPENGLES
|
|
else
|
|
glColor4f(1.0, 1.0, 1.0, opacity);
|
|
#endif
|
|
}
|
|
|
|
if (!m_iconTexture) { // lazy creation
|
|
m_iconTexture = new Texture(m_effectFrame->icon().handle(),
|
|
m_effectFrame->icon().size(),
|
|
m_effectFrame->icon().depth());
|
|
m_iconTexture->setYInverted(true);
|
|
}
|
|
m_iconTexture->bind();
|
|
m_iconTexture->render(region, QRect(topLeft, m_effectFrame->iconSize()));
|
|
m_iconTexture->unbind();
|
|
}
|
|
|
|
// Render text
|
|
if (!m_effectFrame->text().isEmpty()) {
|
|
if (m_effectFrame->isCrossFade() && m_oldTextTexture) {
|
|
if (shader)
|
|
shader->setUniform("opacity", (float)opacity *(1.0f - (float)m_effectFrame->crossFadeProgress()));
|
|
#ifndef KWIN_HAVE_OPENGLES
|
|
else
|
|
glColor4f(1.0, 1.0, 1.0, opacity *(1.0 - m_effectFrame->crossFadeProgress()));
|
|
#endif
|
|
|
|
m_oldTextTexture->bind();
|
|
m_oldTextTexture->render(region, m_effectFrame->geometry());
|
|
m_oldTextTexture->unbind();
|
|
if (shader)
|
|
shader->setUniform("opacity", (float)opacity *(float)m_effectFrame->crossFadeProgress());
|
|
#ifndef KWIN_HAVE_OPENGLES
|
|
else
|
|
glColor4f(1.0, 1.0, 1.0, opacity * m_effectFrame->crossFadeProgress());
|
|
#endif
|
|
} else {
|
|
if (shader)
|
|
shader->setUniform("opacity", (float)opacity);
|
|
#ifndef KWIN_HAVE_OPENGLES
|
|
else
|
|
glColor4f(1.0, 1.0, 1.0, opacity);
|
|
#endif
|
|
}
|
|
if (!m_textTexture) // Lazy creation
|
|
updateTextTexture();
|
|
m_textTexture->bind();
|
|
m_textTexture->render(region, m_effectFrame->geometry());
|
|
m_textTexture->unbind();
|
|
}
|
|
|
|
if (shader) {
|
|
ShaderManager::instance()->popShader();
|
|
}
|
|
glDisable(GL_BLEND);
|
|
#ifndef KWIN_HAVE_OPENGLES
|
|
glPopMatrix();
|
|
glPopAttrib();
|
|
#endif
|
|
}
|
|
|
|
void SceneOpenGL::EffectFrame::updateTexture()
|
|
{
|
|
delete m_texture;
|
|
if (m_effectFrame->style() == EffectFrameStyled) {
|
|
QPixmap pixmap = m_effectFrame->frame().framePixmap();
|
|
m_texture = new Texture(pixmap.handle(), pixmap.size(), pixmap.depth());
|
|
m_texture->setYInverted(true);
|
|
}
|
|
}
|
|
|
|
void SceneOpenGL::EffectFrame::updateTextTexture()
|
|
{
|
|
delete m_textTexture;
|
|
delete m_textPixmap;
|
|
|
|
if (m_effectFrame->text().isEmpty())
|
|
return;
|
|
|
|
// Determine position on texture to paint text
|
|
QRect rect(QPoint(0, 0), m_effectFrame->geometry().size());
|
|
if (!m_effectFrame->icon().isNull() && !m_effectFrame->iconSize().isEmpty())
|
|
rect.setLeft(m_effectFrame->iconSize().width());
|
|
|
|
// If static size elide text as required
|
|
QString text = m_effectFrame->text();
|
|
if (m_effectFrame->isStatic()) {
|
|
QFontMetrics metrics(m_effectFrame->font());
|
|
text = metrics.elidedText(text, Qt::ElideRight, rect.width());
|
|
}
|
|
|
|
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());
|
|
else // TODO: What about no frame? Custom color setting required
|
|
p.setPen(Qt::white);
|
|
p.drawText(rect, m_effectFrame->alignment(), text);
|
|
p.end();
|
|
m_textTexture = new Texture(m_textPixmap->handle(), m_textPixmap->size(), m_textPixmap->depth());
|
|
m_textTexture->setYInverted(true);
|
|
}
|
|
|
|
void SceneOpenGL::EffectFrame::updateUnstyledTexture()
|
|
{
|
|
delete m_unstyledTexture;
|
|
delete m_unstyledPixmap;
|
|
// Based off circle() from kwinxrenderutils.cpp
|
|
#define CS 8
|
|
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());
|
|
p.end();
|
|
#undef CS
|
|
m_unstyledTexture = new Texture(m_unstyledPixmap->handle(), m_unstyledPixmap->size(), m_unstyledPixmap->depth());
|
|
m_unstyledTexture->setYInverted(true);
|
|
}
|
|
|
|
void SceneOpenGL::EffectFrame::cleanup()
|
|
{
|
|
delete m_unstyledTexture;
|
|
m_unstyledTexture = NULL;
|
|
delete m_unstyledPixmap;
|
|
m_unstyledPixmap = NULL;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
#endif
|