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

Scene uses ShaderManager

Browse source
This commit is contained in:
Martin Gräßlin 2010-12-11 10:57:29 +01:00
parent e2e4fe54ba
commit d2cfeef8ae
4 changed files with 28 additions and 109 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

97
scene_opengl.cpp
View file

@ -116,75 +116,6 @@ XShmSegmentInfo SceneOpenGL::shm;
#include "scene_opengl_glx.cpp"
#endif
bool SceneOpenGL::setupSceneShaders()
{
m_sceneShader = new GLShader(":/resources/scene-vertex.glsl", ":/resources/scene-fragment.glsl");
if (m_sceneShader->isValid()) {
m_sceneShader->bind();
m_sceneShader->setUniform("sample", 0);
m_sceneShader->setUniform("displaySize", QVector2D(displayWidth(), displayHeight()));
m_sceneShader->setUniform("debug", debug ? 1 : 0);
m_sceneShader->unbind();
kDebug(1212) << "Scene Shader is valid";
}
else {
delete m_sceneShader;
m_sceneShader = NULL;
kDebug(1212) << "Scene Shader is not valid";
return false;
}
m_genericSceneShader = new GLShader( ":/resources/scene-generic-vertex.glsl", ":/resources/scene-fragment.glsl" );
if (m_genericSceneShader->isValid()) {
m_genericSceneShader->bind();
m_genericSceneShader->setUniform("sample", 0);
m_genericSceneShader->setUniform("debug", debug ? 1 : 0);
QMatrix4x4 projection;
float fovy = 60.0f;
float aspect = 1.0f;
float zNear = 0.1f;
float zFar = 100.0f;
float ymax = zNear * tan(fovy * M_PI / 360.0f);
float ymin = -ymax;
float xmin = ymin * aspect;
float xmax = ymax * aspect;
projection.frustum(xmin, xmax, ymin, ymax, zNear, zFar);
m_genericSceneShader->setUniform("projection", projection);
QMatrix4x4 modelview;
float scaleFactor = 1.1 * tan( fovy * M_PI / 360.0f )/ymax;
modelview.translate(xmin*scaleFactor, ymax*scaleFactor, -1.1);
modelview.scale((xmax-xmin)*scaleFactor/displayWidth(), -(ymax-ymin)*scaleFactor/displayHeight(), 0.001);
m_genericSceneShader->setUniform("modelview", modelview);
m_genericSceneShader->unbind();
kDebug(1212) << "Generic Scene Shader is valid";
}
else {
delete m_genericSceneShader;
m_genericSceneShader = NULL;
delete m_sceneShader;
m_sceneShader = NULL;
kDebug(1212) << "Generic Scene Shader is not valid";
return false;
}
m_colorShader = new GLShader(":/resources/scene-color-vertex.glsl", ":/resources/scene-color-fragment.glsl");
if (m_colorShader->isValid()) {
m_colorShader->bind();
m_colorShader->setUniform("displaySize", QVector2D(displayWidth(), displayHeight()));
m_colorShader->unbind();
kDebug(1212) << "Color Shader is valid";
} else {
delete m_genericSceneShader;
m_genericSceneShader = NULL;
delete m_sceneShader;
m_sceneShader = NULL;
delete m_colorShader;
m_colorShader = NULL;
kDebug(1212) << "Color Scene Shader is not valid";
return false;
}
return true;
}
bool SceneOpenGL::initFailed() const
{
return !init_ok;
@ -338,11 +269,6 @@ void SceneOpenGL::windowOpacityChanged( Toplevel* )
#endif
}
GLShader* SceneOpenGL::sceneShader() const
{
return m_sceneShader;
}
//****************************************
// SceneOpenGL::Texture
//****************************************
@ -528,14 +454,12 @@ void SceneOpenGL::Window::performPaint( int mask, QRegion region, WindowPaintDat
int y = toplevel->y();
double z = 0.0;
bool sceneShader = false;
if (!data.shader && static_cast<SceneOpenGL*>(scene)->hasSceneShader()) {
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 = static_cast<SceneOpenGL*>(scene)->m_genericSceneShader;
data.shader->bind();
data.shader = ShaderManager::instance()->pushShader(ShaderManager::GenericShader);
} else {
data.shader = static_cast<SceneOpenGL*>(scene)->m_sceneShader;
data.shader->bind();
data.shader = ShaderManager::instance()->pushShader(ShaderManager::SimpleShader);
data.shader->setUniform("geometry", QVector4D(x, y, toplevel->width(), toplevel->height()));
}
sceneShader = true;
@ -705,7 +629,7 @@ void SceneOpenGL::Window::performPaint( int mask, QRegion region, WindowPaintDat
if( sceneShader )
{
data.shader->unbind();
ShaderManager::instance()->popShader();
data.shader = NULL;
}
#ifndef KWIN_HAVE_OPENGLES
@ -1212,14 +1136,16 @@ void SceneOpenGL::EffectFrame::render( QRegion region, double opacity, double fr
GLShader* shader = m_effectFrame->shader();
bool sceneShader = false;
if( !shader && static_cast<SceneOpenGL*>(scene)->hasSceneShader() )
if( !shader && ShaderManager::instance()->isValid() )
{
shader = static_cast<SceneOpenGL*>(scene)->m_sceneShader;
shader = ShaderManager::instance()->pushShader(ShaderManager::SimpleShader);
sceneShader = true;
}
if( shader )
{
shader->bind();
if (shader != ShaderManager::instance()->getBoundShader()) {
ShaderManager::instance()->pushShader(shader);
}
if( sceneShader )
shader->setUniform("geometry", QVector4D(0, 0, 0, 0));
shader->setUniform("saturation", 1.0f);
@ -1495,8 +1421,9 @@ void SceneOpenGL::EffectFrame::render( QRegion region, double opacity, double fr
m_textTexture->unbind();
}
if( shader )
shader->unbind();
if (shader) {
ShaderManager::instance()->popShader();
}
glDisable( GL_BLEND );
#ifndef KWIN_HAVE_OPENGLES
glPopMatrix();

8
scene_opengl.h
View file

@ -51,10 +51,6 @@ class SceneOpenGL
virtual void windowAdded( Toplevel* );
virtual void windowClosed( Toplevel*, Deleted* );
virtual void windowDeleted( Deleted* );
GLShader* sceneShader() const;
bool hasSceneShader() const {
return m_sceneShader != NULL && m_genericSceneShader != NULL && m_colorShader != NULL;
}
protected:
virtual void paintGenericScreen( int mask, ScreenPaintData data );
virtual void paintBackground( QRegion region );
@ -72,7 +68,6 @@ class SceneOpenGL
bool selfCheck();
void selfCheckSetup();
bool selfCheckFinish();
bool setupSceneShaders();
GC gcroot;
class FBConfigInfo
{
@ -107,9 +102,6 @@ class SceneOpenGL
#endif
bool init_ok;
bool selfCheckDone;
GLShader* m_sceneShader;
GLShader* m_genericSceneShader;
GLShader* m_colorShader;
bool debug;
};

24
scene_opengl_egl.cpp
View file

@ -31,9 +31,6 @@ SceneOpenGL::SceneOpenGL( Workspace* ws )
: Scene( ws )
, init_ok( false )
, selfCheckDone( true )
, m_sceneShader( NULL )
, m_genericSceneShader( NULL )
, m_colorShader( NULL )
{
if( !initRenderingContext() )
return;
@ -49,11 +46,11 @@ SceneOpenGL::SceneOpenGL( Workspace* ws )
return;
}
debug = qstrcmp( qgetenv( "KWIN_GL_DEBUG" ), "1" ) == 0;
if (!setupSceneShaders()) {
if (!ShaderManager::instance()->isValid()) {
kError( 1212 ) << "Shaders not valid, ES compositing not possible";
return;
}
ShaderManager::instance()->pushShader(ShaderManager::SimpleShader);
if( checkGLError( "Init" ))
{
@ -73,7 +70,6 @@ SceneOpenGL::~SceneOpenGL()
eglDestroySurface( dpy, surface );
eglTerminate( dpy );
eglReleaseThread();
delete m_sceneShader;
SceneOpenGL::EffectFrame::cleanup();
checkGLError( "Cleanup" );
}
@ -245,13 +241,18 @@ void SceneOpenGL::paintGenericScreen(int mask, ScreenPaintData data)
screenTransformation.translate(-data.rotation->xRotationPoint, -data.rotation->yRotationPoint, -data.rotation->zRotationPoint);
}
screenTransformation.scale(data.xScale, data.yScale, data.zScale);
m_genericSceneShader->bind();
m_genericSceneShader->setUniform("screenTransformation", screenTransformation);
GLShader *shader = ShaderManager::instance()->pushShader(ShaderManager::GenericShader);
shader->setUniform("screenTransformation", screenTransformation);
} else if ((mask & PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS) || (mask & PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_WITHOUT_FULL_REPAINTS)) {
m_genericSceneShader->bind();
m_genericSceneShader->setUniform("screenTransformation", QMatrix4x4());
GLShader *shader = ShaderManager::instance()->pushShader(ShaderManager::GenericShader);
shader->setUniform("screenTransformation", QMatrix4x4());
}
Scene::paintGenericScreen(mask, data);
if ((mask & PAINT_SCREEN_TRANSFORMED) ||
(mask & PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS) ||
(mask & PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_WITHOUT_FULL_REPAINTS)) {
ShaderManager::instance()->popShader();
}
}
void SceneOpenGL::paintBackground(QRegion region)
@ -278,8 +279,9 @@ void SceneOpenGL::paintBackground(QRegion region)
vbo.setUseColor(true);
vbo.setUseShader(true);
vbo.setData(verts.count() / 2, 2, verts.data(), NULL);
m_colorShader->bind();
ShaderManager::instance()->pushShader(ShaderManager::ColorShader);
vbo.render(GL_TRIANGLES);
ShaderManager::instance()->popShader();
}
//****************************************

8
scene_opengl_glx.cpp
View file

@ -39,9 +39,6 @@ SceneOpenGL::SceneOpenGL( Workspace* ws )
: Scene( ws )
, init_ok( false )
, selfCheckDone( false )
, m_sceneShader( NULL )
, m_genericSceneShader( NULL )
, m_colorShader( NULL )
{
if( !Extensions::glxAvailable())
{
@ -101,7 +98,9 @@ SceneOpenGL::SceneOpenGL( Workspace* ws )
GLPlatform::instance()->detect();
if( GLPlatform::instance()->supports( GLSL ) )
{
setupSceneShaders();
if (!ShaderManager::instance()->isValid()) {
kDebug(1212) << "No Scene Shaders available";
}
}
// OpenGL scene setup
@ -179,7 +178,6 @@ SceneOpenGL::~SceneOpenGL()
glXDestroyPixmap( display(), last_pixmap );
glXDestroyContext( display(), ctxdrawable );
}
delete m_sceneShader;
SceneOpenGL::EffectFrame::cleanup();
checkGLError( "Cleanup" );
}