workspace/kwin/effects/snow.cpp

   1 /********************************************************************
   2  KWin - the KDE window manager
   3  This file is part of the KDE project.
   4
   5  Copyright (C) 2007 Martin Gräßlin <ubuntu@martin-graesslin.com>
   6  Copyright (C) 2008 Torgny Johansson <torgny.johansson@gmail.com>
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 *********************************************************************/
  21
  22 #include "snow.h"
  23
  24 #include <kwinconfig.h>
  25
  26 #include <kaction.h>
  27 #include <kactioncollection.h>
  28 #include <kconfiggroup.h>
  29 #include <kglobal.h>
  30 #include <klocale.h>
  31 #include <kstandarddirs.h>
  32
  33 #include <kdebug.h>
  34
  35 #include <ctime>
  36
  37 #ifdef KWIN_HAVE_OPENGL_COMPOSITING
  38 #include <GL/gl.h>
  39 #endif
  40
  41 namespace KWin
  42 {
  43
  44 KWIN_EFFECT( snow, SnowEffect )
  45 KWIN_EFFECT_SUPPORTED( snow, SnowEffect::supported() )
  46
  47 SnowEffect::SnowEffect()
  48     : texture( NULL )
  49     , active( false)
  50     , snowBehindWindows( false )
  51     , mShader( 0 )
  52     , mInited( false )
  53     , mUseShader( true )
  54     , hasSnown( false )
  55     {
  56     srandom( std::time( NULL ) );
  57     nextFlakeMillis = 0;
  58     KActionCollection* actionCollection = new KActionCollection( this );
  59     KAction* a = static_cast< KAction* >( actionCollection->addAction( "Snow" ));
  60     a->setText( i18n("Snow" ));
  61     a->setGlobalShortcut( KShortcut( Qt::CTRL + Qt::META + Qt::Key_F12 ));
  62     connect( a, SIGNAL( triggered( bool )), this, SLOT( toggle()));
  63     reconfigure( ReconfigureAll );
  64     }
  65
  66 SnowEffect::~SnowEffect()
  67     {
  68     delete texture;
  69     if( active )
  70         delete mShader;
  71     }
  72
  73 bool SnowEffect::supported()
  74     {
  75     return effects->compositingType() == OpenGLCompositing;
  76     }
  77
  78 void SnowEffect::reconfigure( ReconfigureFlags )
  79     {
  80     KConfigGroup conf = effects->effectConfig("Snow");
  81     mNumberFlakes = conf.readEntry("Number", 200);
  82     mMinFlakeSize = conf.readEntry("MinFlakes", 10);
  83     mMaxFlakeSize = conf.readEntry("MaxFlakes", 50);
  84     mMaxVSpeed = conf.readEntry("MaxVSpeed", 2);
  85     mMaxHSpeed = conf.readEntry("MaxHSpeed", 1);
  86     snowBehindWindows = conf.readEntry("BehindWindows", true);
  87     }
  88
  89 void SnowEffect::prePaintScreen( ScreenPrePaintData& data, int time )
  90     {
  91     if ( active )
  92         {
  93             // if number of active snowflakes is smaller than maximum number
  94             // create a random new snowflake
  95             nextFlakeMillis -= time;
  96             if ( ( nextFlakeMillis <= 0 ) && flakes.count() < mNumberFlakes)
  97                 {
  98                 int size = 0;
  99                 while ( size < mMinFlakeSize )
 100                     size = random() % mMaxFlakeSize;
 101                 SnowFlake flake = SnowFlake( random() % (displayWidth() - size), -1 * size, size, size, mMaxVSpeed, mMaxHSpeed );
 102                 flakes.append( flake );
 103
 104                 // calculation of next time of snowflake
 105                 // depends on the time the flow needs to get to the bottom (screen size)
 106                 // and the fps
 107                 long next = ((500/(time+5))*(Effect::displayHeight()/flake.getVSpeed()))/mNumberFlakes;
 108                 nextFlakeMillis = next;
 109                 }
 110         data.mask |= PAINT_SCREEN_TRANSFORMED;
 111         hasSnown = false;
 112         }
 113     effects->prePaintScreen( data, time );
 114     }
 115
 116 void SnowEffect::paintScreen( int mask, QRegion region, ScreenPaintData& data )
 117     {
 118     if( active && snowBehindWindows )
 119         repaintRegion = QRegion( 0, 0, displayWidth(), displayHeight() );
 120     effects->paintScreen( mask, region, data ); // paint normal screen
 121     if( active && !snowBehindWindows )
 122         snowing( region );
 123     }
 124
 125 void SnowEffect::snowing( QRegion& region )
 126     {
 127     if(! texture ) loadTexture();
 128     if( texture )
 129         {
 130         glActiveTexture(GL_TEXTURE0);
 131         texture->bind();
 132         if( mUseShader && !mInited )
 133             mUseShader = loadShader();
 134         glPushAttrib( GL_CURRENT_BIT | GL_ENABLE_BIT );
 135         glEnable( GL_BLEND );
 136         glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
 137
 138         if( mUseShader )
 139             {
 140             mShader->bind();
 141             QRect rect = region.boundingRect();
 142             mShader->setUniform( "left", rect.x() );
 143             mShader->setUniform( "right", rect.x() + rect.width() );
 144             mShader->setUniform( "top", rect.y() );
 145             mShader->setUniform( "bottom", rect.y() + rect.height() );
 146             }
 147         else
 148             glNewList( list, GL_COMPILE_AND_EXECUTE );
 149         for (int i=0; i<flakes.count(); i++)
 150             {
 151             SnowFlake& flake = flakes[i];
 152             if( !hasSnown )
 153                 {
 154                 // only update during first paint in one frame
 155                 if( flake.addFrame() == 0 )
 156                     {
 157                     flakes.removeAt( i-- );
 158                     continue;
 159                     }
 160                 }
 161
 162             if( mUseShader )
 163                 {
 164                 // use shader
 165                 mShader->setUniform( "angle", flake.getRotationSpeed() );
 166                 mShader->setUniform( "x", flake.getX() );
 167                 mShader->setUniform( "hSpeed", flake.getHSpeed() );
 168                 mShader->setUniform( "vSpeed", flake.getVSpeed() );
 169                 mShader->setUniform( "frames", flake.getFrames() );
 170                 mShader->setUniform( "width", flake.getWidth() );
 171                 mShader->setUniform( "height", flake.getHeight() );
 172                 glCallList( list );
 173                 }
 174             else
 175                 {
 176                 if( !hasSnown )
 177                     {
 178                     // only update during first paint in one frame
 179                     flake.updateSpeedAndRotation();
 180                     }
 181                 // no shader
 182                 // save the matrix
 183                 glPushMatrix();
 184
 185                 // translate to the center of the flake
 186                 glTranslatef(flake.getWidth()/2 + flake.getX(), flake.getHeight()/2 + flake.getY(), 0);
 187
 188                 // rotate around the Z-axis
 189                 glRotatef(flake.getRotationAngle(), 0.0, 0.0, 1.0);
 190
 191                 // translate back to the starting point
 192                 glTranslatef(-flake.getWidth()/2 - flake.getX(), -flake.getHeight()/2 - flake.getY(), 0);
 193
 194                 // paint the snowflake
 195                 texture->render( region, flake.getRect());
 196
 197                 // restore the matrix
 198                 glPopMatrix();
 199                 }
 200             }
 201         if( mUseShader )
 202             {
 203             mShader->unbind();
 204             }
 205         else
 206             glEndList();
 207         glDisable( GL_BLEND );
 208         texture->unbind();
 209         glPopAttrib();
 210         hasSnown = true;
 211         }
 212     }
 213
 214 void SnowEffect::postPaintScreen()
 215     {
 216     if( active )
 217         {
 218         if( snowBehindWindows )
 219             effects->addRepaint( repaintRegion );
 220         else
 221             effects->addRepaintFull();
 222         }
 223     effects->postPaintScreen();
 224     }
 225
 226 void SnowEffect::paintWindow( EffectWindow* w, int mask, QRegion region, WindowPaintData& data )
 227     {
 228     if( active && snowBehindWindows && !w->isDesktop() && !w->isDock() )
 229         {
 230         repaintRegion -= QRegion( w->geometry() );
 231         }
 232     effects->paintWindow( w, mask, region, data );
 233     if( active && w->isDesktop() && snowBehindWindows )
 234         {
 235         QRect rect = effects->clientArea( FullScreenArea, w->screen(), effects->currentDesktop());
 236         QRegion snowRegion( rect.x() + data.xTranslate, rect.y() + data.yTranslate,
 237             (double)rect.width()*data.xScale, (double)rect.height()*data.yScale);
 238         if( mUseShader )
 239             {
 240             // have to adjust the y values to fit OpenGL
 241             // in OpenGL y==0 is at bottom, in Qt at top
 242             int y = 0;
 243             if( effects->numScreens() > 1 )
 244                 {
 245                 QRect fullArea = effects->clientArea( FullArea, 0, 1 );
 246                 if( fullArea.height() != rect.height() )
 247                     {
 248                     if( rect.y() == 0 )
 249                         y = fullArea.height() - rect.height();
 250                     else
 251                         y = fullArea.height() - rect.y() - rect.height();
 252                     }
 253                 }
 254             snowRegion = QRegion( rect.x() + data.xTranslate,
 255                 y + rect.height() - data.yTranslate - (double)rect.height()*data.yScale,
 256                 (double)rect.width()*data.xScale, (double)rect.height()*data.yScale);
 257             }
 258         glPushMatrix();
 259         glTranslatef( rect.x() + data.xTranslate, rect.y() + data.yTranslate, 0.0 );
 260         glScalef( data.xScale, data.yScale, 1.0 );
 261         snowing( snowRegion );
 262         glPopMatrix();
 263         }
 264     }
 265
 266 void SnowEffect::toggle()
 267     {
 268 #ifdef KWIN_HAVE_OPENGL_COMPOSITING
 269     active = !active;
 270     if( active )
 271         {
 272         list = glGenLists(1);
 273         }
 274     else
 275         {
 276         glDeleteLists( list, 1 );
 277         flakes.clear();
 278         if( mUseShader )
 279             {
 280             delete mShader;
 281             mInited = false;
 282             mUseShader = true;
 283             }
 284         }
 285     effects->addRepaintFull();
 286 #endif
 287     }
 288
 289 bool SnowEffect::loadShader()
 290     {
 291     mInited = true;
 292     if( !(GLShader::fragmentShaderSupported() &&
 293         (effects->compositingType() == OpenGLCompositing)) )
 294         {
 295         kDebug(1212) << "Shaders not supported - waisting CPU cycles" << endl;
 296         return false;
 297         }
 298     QString fragmentshader =  KGlobal::dirs()->findResource("data", "kwin/snow.frag");
 299     QString vertexshader =  KGlobal::dirs()->findResource("data", "kwin/snow.vert");
 300     if(fragmentshader.isEmpty() || vertexshader.isEmpty())
 301         {
 302         kDebug(1212) << "Couldn't locate shader files" << endl;
 303         return false;
 304         }
 305
 306     mShader = new GLShader(vertexshader, fragmentshader);
 307     if(!mShader->isValid())
 308         {
 309         kDebug(1212) << "The shader failed to load!" << endl;
 310         return false;
 311         }
 312     else
 313         {
 314         mShader->bind();
 315         mShader->setUniform( "snowTexture", 0 );
 316         mShader->unbind();
 317         }
 318     kDebug(1212) << "using shader";
 319
 320     glNewList( list, GL_COMPILE );
 321     glBegin( GL_QUADS );
 322     glTexCoord2f( 0.0f, 0.0f );
 323     glVertex2i( 0, 0 );
 324     glTexCoord2f( 1.0f, 0.0f );
 325     glVertex2i( 0, 0 );
 326     glTexCoord2f( 1.0f, 1.0f );
 327     glVertex2i( 0, 0 );
 328     glTexCoord2f( 0.0f, 1.0f );
 329     glVertex2i( 0, 0 );
 330     glEnd();
 331     glEndList();
 332     return true;
 333     }
 334
 335 void SnowEffect::loadTexture()
 336     {
 337     QString file = KGlobal::dirs()->findResource( "appdata", "snowflake.png" );
 338     if( file.isEmpty())
 339         return;
 340     texture = new GLTexture( file );
 341     }
 342
 343
 344 // the snowflake class
 345 SnowFlake::SnowFlake(int x, int y, int width, int height, int maxVSpeed, int maxHSpeed)
 346     {
 347     int minVSpeed = maxVSpeed - 8; // 8 gives a nice difference in speed
 348     if(minVSpeed < 1) minVSpeed = 1;
 349     vSpeed = random()%maxVSpeed + minVSpeed;
 350
 351     hSpeed = random()%(maxHSpeed+1);
 352     if(random()%2 < 1) hSpeed = -hSpeed; // to create negative hSpeeds at random
 353
 354     rotationAngle = 0;
 355     rotationSpeed = random()%4 - 2;
 356     if(rotationSpeed == 0) rotationSpeed = 0.5;
 357     rect = QRect(x, y, width, height);
 358     frameCounter = 0;
 359     maxFrames = displayHeight() / vSpeed;
 360     if( hSpeed > 0 )
 361         maxFrames = qMin( maxFrames, (displayWidth() - x)/hSpeed );
 362     else if( hSpeed < 0 )
 363         maxFrames = qMin( maxFrames, (x + width)/(-hSpeed) );
 364     }
 365
 366 SnowFlake::~SnowFlake()
 367     {
 368     }
 369
 370 int SnowFlake::getHSpeed()
 371     {
 372     return hSpeed;
 373     }
 374
 375 QRect SnowFlake::getRect()
 376     {
 377     return rect;
 378     }
 379
 380 void SnowFlake::updateSpeedAndRotation()
 381     {
 382     rotationAngle = rotationAngle+rotationSpeed;
 383     rect.translate(hSpeed, vSpeed);
 384     }
 385
 386 float SnowFlake::getRotationAngle()
 387     {
 388     return rotationAngle;
 389     }
 390
 391 float SnowFlake::getRotationSpeed()
 392     {
 393     return rotationSpeed;
 394     }
 395
 396 int SnowFlake::getVSpeed()
 397     {
 398     return vSpeed;
 399     }
 400
 401 int SnowFlake::getHeight()
 402     {
 403     return rect.height();
 404     }
 405
 406 int SnowFlake::getWidth()
 407     {
 408     return rect.width();
 409     }
 410
 411 int SnowFlake::getX()
 412     {
 413     return rect.x();
 414     }
 415
 416 int SnowFlake::getY()
 417     {
 418     return rect.y();
 419     }
 420
 421 void SnowFlake::setHeight(int height)
 422     {
 423     rect.setHeight(height);
 424     }
 425
 426 void SnowFlake::setWidth(int width)
 427     {
 428     rect.setWidth(width);
 429     }
 430
 431 void SnowFlake::setX(int x)
 432     {
 433     rect.setX(x);
 434     }
 435
 436 void SnowFlake::setY(int y)
 437     {
 438     rect.setY(y);
 439     }
 440
 441 int SnowFlake::addFrame()
 442     {
 443     return ( maxFrames - (++frameCounter) );
 444     }
 445
 446 int SnowFlake::getFrames()
 447     {
 448     return frameCounter;
 449     }
 450
 451 } // namespace