#include <gltexture.h>
|  | 
|  | GLTexture (GLenum target) | 
|  | 
| bool | create () | 
|  | 
| virtual | ~GLTexture () | 
|  | 
| bool | isNull () const | 
|  | 
| QSize | size () const | 
|  | 
| void | setSize (const QSize &size) | 
|  | 
| int | width () const | 
|  | 
| int | height () const | 
|  | 
| void | setContentTransform (OutputTransform transform) | 
|  | 
| OutputTransform | contentTransform () const | 
|  | 
| void | setSwizzle (GLenum red, GLenum green, GLenum blue, GLenum alpha) | 
|  | 
| QMatrix4x4 | matrix (TextureCoordinateType type) const | 
|  | 
| void | update (const QImage &image, const QPoint &offset=QPoint(0, 0), const QRect &src=QRect()) | 
|  | 
| void | bind () | 
|  | 
| void | unbind () | 
|  | 
| void | render (const QSizeF &size) | 
|  | 
| void | render (const QRegion ®ion, const QSizeF &size, bool hardwareClipping=false) | 
|  | 
| void | render (const QRectF &source, const QRegion ®ion, const QSizeF &targetSize, bool hardwareClipping=false) | 
|  | 
| GLuint | texture () const | 
|  | 
| GLenum | target () const | 
|  | 
| GLenum | filter () const | 
|  | 
| GLenum | internalFormat () const | 
|  | 
| QImage | toImage () | 
|  | 
| void | clear () | 
|  | Make the texture fully transparent. 
 | 
|  | 
| void | setDirty () | 
|  | 
| bool | isDirty () const | 
|  | 
| void | setFilter (GLenum filter) | 
|  | 
| void | setWrapMode (GLenum mode) | 
|  | 
| void | generateMipmaps () | 
|  | 
Definition at line 39 of file gltexture.h.
 
◆ GLTexture() [1/2]
  
  | 
        
          | KWin::GLTexture::GLTexture | ( | GLenum | target | ) |  |  | explicit | 
 
 
◆ ~GLTexture()
  
  | 
        
          | KWin::GLTexture::~GLTexture | ( |  | ) |  |  | virtual | 
 
 
◆ GLTexture() [2/2]
  
  | 
        
          | KWin::GLTexture::GLTexture | ( | GLenum | target, |  
          |  |  | GLuint | textureId, |  
          |  |  | GLenum | internalFormat, |  
          |  |  | const QSize & | size, |  
          |  |  | int | levels, |  
          |  |  | bool | owning, |  
          |  |  | OutputTransform | transform ) |  | explicitprotected | 
 
 
◆ allocate()
  
  | 
        
          | std::unique_ptr< GLTexture > KWin::GLTexture::allocate | ( | GLenum | internalFormat, |  
          |  |  | const QSize & | size, |  
          |  |  | int | levels = 1 ) |  | static | 
 
 
◆ bind()
      
        
          | void KWin::GLTexture::bind | ( |  | ) |  | 
      
 
 
◆ clear()
      
        
          | void KWin::GLTexture::clear | ( |  | ) |  | 
      
 
Make the texture fully transparent. 
Definition at line 423 of file gltexture.cpp.
 
 
◆ contentTransform()
- Returns
- the transform between the content and the buffer 
Definition at line 523 of file gltexture.cpp.
 
 
◆ create()
      
        
          | bool KWin::GLTexture::create | ( |  | ) |  | 
      
 
Creates the underlying texture object. Returns true if the texture has been created successfully; otherwise returns false. Note that this does not allocate any storage for the texture. 
Definition at line 111 of file gltexture.cpp.
 
 
◆ createNonOwningWrapper()
  
  | 
        
          | std::unique_ptr< GLTexture > KWin::GLTexture::createNonOwningWrapper | ( | GLuint | textureId, |  
          |  |  | GLenum | internalFormat, |  
          |  |  | const QSize & | size ) |  | static | 
 
 
◆ filter()
      
        
          | GLenum KWin::GLTexture::filter | ( |  | ) | const | 
      
 
 
◆ framebufferObjectSupported()
  
  | 
        
          | bool KWin::GLTexture::framebufferObjectSupported | ( |  | ) |  |  | static | 
 
 
◆ generateMipmaps()
      
        
          | void KWin::GLTexture::generateMipmaps | ( |  | ) |  | 
      
 
 
◆ height()
      
        
          | int KWin::GLTexture::height | ( |  | ) | const | 
      
 
 
◆ internalFormat()
      
        
          | GLenum KWin::GLTexture::internalFormat | ( |  | ) | const | 
      
 
 
◆ isDirty()
      
        
          | bool KWin::GLTexture::isDirty | ( |  | ) | const | 
      
 
 
◆ isNull()
      
        
          | bool KWin::GLTexture::isNull | ( |  | ) | const | 
      
 
 
◆ matrix()
Returns a matrix that transforms texture coordinates of the given type, taking the texture target and the y-inversion flag into account.
- Since
- 4.11 
Definition at line 551 of file gltexture.cpp.
 
 
◆ onDamage()
  
  | 
        
          | void KWin::GLTexture::onDamage | ( |  | ) |  |  | protectedvirtual | 
 
 
◆ render() [1/3]
      
        
          | void KWin::GLTexture::render | ( | const QRectF & | source, | 
        
          |  |  | const QRegion & | region, | 
        
          |  |  | const QSizeF & | targetSize, | 
        
          |  |  | bool | hardwareClipping = false ) | 
      
 
 
◆ render() [2/3]
      
        
          | void KWin::GLTexture::render | ( | const QRegion & | region, | 
        
          |  |  | const QSizeF & | size, | 
        
          |  |  | bool | hardwareClipping = false ) | 
      
 
 
◆ render() [3/3]
      
        
          | void KWin::GLTexture::render | ( | const QSizeF & | size | ) |  | 
      
 
 
◆ setContentTransform()
sets the transform between the content and the buffer 
Definition at line 515 of file gltexture.cpp.
 
 
◆ setDirty()
      
        
          | void KWin::GLTexture::setDirty | ( |  | ) |  | 
      
 
 
◆ setFilter()
      
        
          | void KWin::GLTexture::setFilter | ( | GLenum | filter | ) |  | 
      
 
 
◆ setSize()
      
        
          | void KWin::GLTexture::setSize | ( | const QSize & | size | ) |  | 
      
 
 
◆ setSwizzle()
      
        
          | void KWin::GLTexture::setSwizzle | ( | GLenum | red, | 
        
          |  |  | GLenum | green, | 
        
          |  |  | GLenum | blue, | 
        
          |  |  | GLenum | alpha ) | 
      
 
Specifies which component of a texel is placed in each respective component of the vector returned to the shader.
Valid values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_ONE and GL_ZERO.
- See also
- swizzleSupported() 
- Since
- 5.2 
Definition at line 528 of file gltexture.cpp.
 
 
◆ setWrapMode()
      
        
          | void KWin::GLTexture::setWrapMode | ( | GLenum | mode | ) |  | 
      
 
 
◆ size()
      
        
          | QSize KWin::GLTexture::size | ( |  | ) | const | 
      
 
 
◆ supportsFormatRG()
  
  | 
        
          | bool KWin::GLTexture::supportsFormatRG | ( |  | ) |  |  | static | 
 
Returns true if texture formats R* are supported, and false otherwise.
This requires OpenGL 3.0, GL_ARB_texture_rg or OpenGL ES 3.0 or GL_EXT_texture_rg.
- Since
- 5.2.1 
Definition at line 566 of file gltexture.cpp.
 
 
◆ supportsSwizzle()
  
  | 
        
          | bool KWin::GLTexture::supportsSwizzle | ( |  | ) |  |  | static | 
 
Returns true if texture swizzle is supported, and false otherwise
Texture swizzle requires OpenGL 3.3, GL_ARB_texture_swizzle, or OpenGL ES 3.0.
- Since
- 5.2 
Definition at line 561 of file gltexture.cpp.
 
 
◆ target()
      
        
          | GLenum KWin::GLTexture::target | ( |  | ) | const | 
      
 
 
◆ texture()
      
        
          | GLuint KWin::GLTexture::texture | ( |  | ) | const | 
      
 
 
◆ toImage()
      
        
          | QImage KWin::GLTexture::toImage | ( |  | ) |  | 
      
 
 
◆ unbind()
      
        
          | void KWin::GLTexture::unbind | ( |  | ) |  | 
      
 
 
◆ update()
      
        
          | void KWin::GLTexture::update | ( | const QImage & | image, | 
        
          |  |  | const QPoint & | offset = QPoint(0, 0), | 
        
          |  |  | const QRect & | src = QRect() ) | 
      
 
 
◆ upload() [1/2]
  
  | 
        
          | std::unique_ptr< GLTexture > KWin::GLTexture::upload | ( | const QImage & | image | ) |  |  | static | 
 
 
◆ upload() [2/2]
  
  | 
        
          | std::unique_ptr< GLTexture > KWin::GLTexture::upload | ( | const QPixmap & | pixmap | ) |  |  | static | 
 
 
◆ width()
      
        
          | int KWin::GLTexture::width | ( |  | ) | const | 
      
 
 
The documentation for this class was generated from the following files: