workspace/kwin/lib/kwinglutils.h

   1 /********************************************************************
   2  KWin - the KDE window manager
   3  This file is part of the KDE project.
   4
   5 Copyright (C) 2006-2007 Rivo Laks <rivolaks@hot.ee>
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 *********************************************************************/
  20
  21 #ifndef KWIN_GLUTILS_H
  22 #define KWIN_GLUTILS_H
  23
  24 #include <kwinconfig.h> // KWIN_HAVE_OPENGL
  25
  26 #ifdef KWIN_HAVE_OPENGL
  27 #include <kwinglutils_funcs.h>
  28
  29 #include <QtGui/QPixmap>
  30
  31 #include <QtGui/QImage>
  32 #include <QtCore/QSize>
  33
  34 /** @addtogroup kwineffects */
  35 /** @{ */
  36
  37
  38 template< class K, class V > class QHash;
  39
  40
  41 namespace KWin
  42 {
  43
  44
  45 class GLTexture;
  46
  47
  48 // Initializes GLX function pointers
  49 void KWIN_EXPORT initGLX();
  50 // Initializes OpenGL stuff. This includes resolving function pointers as
  51 //  well as checking for GL version and extensions
  52 //  Note that GL context has to be created by the time this function is called
  53 void KWIN_EXPORT initGL();
  54
  55
  56 // Number of supported texture units
  57 extern KWIN_EXPORT int glTextureUnitsCount;
  58
  59
  60 bool KWIN_EXPORT hasGLVersion(int major, int minor, int release = 0);
  61 bool KWIN_EXPORT hasGLXVersion(int major, int minor, int release = 0);
  62 // use for both OpenGL and GLX extensions
  63 bool KWIN_EXPORT hasGLExtension(const QString& extension);
  64
  65 // detect OpenGL error (add to various places in code to pinpoint the place)
  66 bool KWIN_EXPORT checkGLError( const char* txt );
  67
  68 inline bool KWIN_EXPORT isPowerOfTwo( int x ) { return (( x & ( x - 1 )) == 0 ); }
  69 /**
  70  * @return power of two integer _greater or equal to_ x.
  71  *  E.g. nearestPowerOfTwo(513) = nearestPowerOfTwo(800) = 1024
  72  **/
  73 int KWIN_EXPORT nearestPowerOfTwo( int x );
  74
  75 /**
  76  * Renders quads using given vertices.
  77  * If texture is not 0, each texture coordinate much have two components (st).
  78  * If color is not 0, each color much have four components (rgba).
  79  *
  80  * @param count number of vertices to use.
  81  * @param dim number of components per vertex coordinate in vertices array.
  82  * @param stride byte offset of consecutive elements in arrays. If 0, then
  83  *  arrays must be tighly packed. Stride must be a multiple of sizeof(float)!
  84  **/
  85 KWIN_EXPORT void renderGLGeometry( const QRegion& region, int count,
  86     const float* vertices, const float* texture = 0, const float* color = 0,
  87     int dim = 2, int stride = 0 );
  88 /**
  89  * Same as above, renders without specified region
  90  **/
  91 KWIN_EXPORT void renderGLGeometry( int count,
  92     const float* vertices, const float* texture = 0, const float* color = 0,
  93     int dim = 2, int stride = 0 );
  94
  95
  96 KWIN_EXPORT void renderGLGeometryImmediate( int count,
  97     const float* vertices, const float* texture = 0, const float* color = 0,
  98     int dim = 2, int stride = 0 );
  99
 100
 101 KWIN_EXPORT void renderRoundBox( const QRect& area, float roundness = 10.0f, GLTexture* texture = 0 );
 102 KWIN_EXPORT void renderRoundBoxWithEdge( const QRect& area, float roundness = 10.0f );
 103
 104
 105 class KWIN_EXPORT GLTexture
 106     {
 107     public:
 108         GLTexture();
 109         explicit GLTexture( const QImage& image, GLenum target = GL_TEXTURE_2D );
 110         explicit GLTexture( const QPixmap& pixmap, GLenum target = GL_TEXTURE_2D );
 111         GLTexture( const QString& fileName );
 112         GLTexture( int width, int height );
 113         virtual ~GLTexture();
 114
 115         bool isNull() const;
 116
 117         virtual bool load( const QImage& image, GLenum target = GL_TEXTURE_2D );
 118         virtual bool load( const QPixmap& pixmap, GLenum target = GL_TEXTURE_2D );
 119         virtual bool load( const QString& fileName );
 120         virtual void discard();
 121         virtual void bind();
 122         virtual void unbind();
 123         void render( QRegion region, const QRect& rect );
 124         void enableUnnormalizedTexCoords();
 125         void disableUnnormalizedTexCoords();
 126
 127         GLuint texture() const;
 128         GLenum target() const;
 129         GLenum filter() const;
 130         virtual bool isDirty() const;
 131         void setTexture( GLuint texture );
 132         void setTarget( GLenum target );
 133         void setFilter( GLenum filter );
 134         void setWrapMode( GLenum mode );
 135         virtual void setDirty();
 136
 137         static void initStatic();
 138         static bool NPOTTextureSupported()  { return mNPOTTextureSupported; }
 139         static bool framebufferObjectSupported()  { return mFramebufferObjectSupported; }
 140         static bool saturationSupported()  { return mSaturationSupported; }
 141
 142     protected:
 143         void enableFilter();
 144         QImage convertToGLFormat( const QImage& img ) const;
 145
 146         GLuint mTexture;
 147         GLenum mTarget;
 148         GLenum mFilter;
 149         QSize mSize;
 150         QSizeF mScale; // to un-normalize GL_TEXTURE_2D
 151         bool y_inverted; // texture has y inverted
 152         bool can_use_mipmaps;
 153         bool has_valid_mipmaps;
 154
 155     private:
 156         void init();
 157
 158         static bool mNPOTTextureSupported;
 159         static bool mFramebufferObjectSupported;
 160         static bool mSaturationSupported;
 161     };
 162
 163 class KWIN_EXPORT GLShader
 164     {
 165     public:
 166         GLShader(const QString& vertexfile, const QString& fragmentfile);
 167         ~GLShader();
 168
 169         bool isValid() const  { return mValid; }
 170         void bind();
 171         void unbind();
 172
 173         int uniformLocation(const QString& name);
 174         bool setUniform(const QString& name, float value);
 175         bool setUniform(const QString& name, int value);
 176         int attributeLocation(const QString& name);
 177         bool setAttribute(const QString& name, float value);
 178
 179
 180         static void initStatic();
 181         static bool fragmentShaderSupported()  { return mFragmentShaderSupported; }
 182         static bool vertexShaderSupported()  { return mVertexShaderSupported; }
 183
 184
 185     protected:
 186         bool loadFromFiles(const QString& vertexfile, const QString& fragmentfile);
 187         bool load(const QString& vertexsource, const QString& fragmentsource);
 188
 189
 190     private:
 191         unsigned int mProgram;
 192         bool mValid;
 193         QHash< QString, int >* mVariableLocations;
 194         static bool mFragmentShaderSupported;
 195         static bool mVertexShaderSupported;
 196     };
 197
 198 /**
 199  * @short Render target object
 200  *
 201  * Render target object enables you to render onto a texture. This texture can
 202  *  later be used to e.g. do post-processing of the scene.
 203  *
 204  * @author Rivo Laks <rivolaks@hot.ee>
 205  **/
 206 class KWIN_EXPORT GLRenderTarget
 207 {
 208     public:
 209         /**
 210          * Constructs a GLRenderTarget
 211          * @param color texture where the scene will be rendered onto
 212          **/
 213         GLRenderTarget(GLTexture* color);
 214         ~GLRenderTarget();
 215
 216         /**
 217          * Enables this render target.
 218          * All OpenGL commands from now on affect this render target until the
 219          *  @ref disable method is called
 220          **/
 221         bool enable();
 222         /**
 223          * Disables this render target, activating whichever target was active
 224          *  when @ref enable was called.
 225          **/
 226         bool disable();
 227
 228         bool valid() const  { return mValid; }
 229
 230         static void initStatic();
 231         static bool supported()  { return mSupported; }
 232
 233
 234     protected:
 235         void initFBO();
 236
 237
 238     private:
 239         static bool mSupported;
 240
 241         GLTexture* mTexture;
 242         bool mValid;
 243
 244         GLuint mFramebuffer;
 245 };
 246
 247 } // namespace
 248
 249 #endif
 250
 251 /** @} */
 252
 253 #endif