QGLContextPrivate Class Reference

#include <qgl_p.h>

Public Functions
QGLTexture *	bindTexture (const QImage &image, GLenum target, GLint format, QGLContext::BindOptions options)
QGLTexture *	bindTexture (const QImage &image, GLenum target, GLint format, const qint64 key, QGLContext::BindOptions options)
QGLTexture *	bindTexture (const QPixmap &pixmap, GLenum target, GLint format, QGLContext::BindOptions options)
QGLTexture *	bindTextureFromNativePixmap (QPixmap *, const qint64 key, QGLContext::BindOptions options)
void	cleanup ()
void	clearDrawable ()
QImage	convertToGLFormat (const QImage &image, bool force_premul, GLenum texture_format)
void	destroyEglSurfaceForDevice ()
EGLSurface	eglSurfaceForDevice () const
void	init (QPaintDevice *dev, const QGLFormat &format)
int	maxTextureSize ()
	QGLContextPrivate (QGLContext *context)
void	setVertexAttribArrayEnabled (int arrayIndex, bool enabled=true)
void	swapRegion (const QRegion &region)
void	syncGlState ()
QGLTexture *	textureCacheLookup (const qint64 key, GLenum target)
void *	tryFormat (const QGLFormat &format)
void	updateFormatVersion ()
	~QGLContextPrivate ()

Static Public Functions
static QGLContextGroup *	contextGroup (const QGLContext *ctx)
static void	destroyGlSurfaceForPixmap (QPixmapData *)
static QGLExtensionFuncs &	extensionFuncs (const QGLContext *ctx)
static Q_OPENGL_EXPORT QGLExtensionFuncs &	extensionFuncs (const QGLContext *)
static void	setExtraWindowSurfaceCreationProps (QEglProperties *props)
static void	unbindPixmapFromTexture (QPixmapData *)
static void	setCurrentContext (QGLContext *context)

Public Variables
QPaintEngine *	active_engine
QHash< QPixmapData *, QPixmap >	boundPixmaps
QGLCmap *	cmap
uint	crWin: 1
GLuint	current_fbo
void *	cx
HDC	dc
GLuint	default_fbo
QEglContext *	eglContext
EGLSurface	eglSurface
QGLExtensions::Extensions	extension_flags
uint	extension_flags_cached: 1
GLuint	fbo
QGLFormat	glFormat
quint32	gpm
QGLContextGroup *	group
HBITMAP	hbitmap
HDC	hbitmap_hdc
uint	initDone: 1
uint	internal_context: 1
QHash< QGLContextResourceBase *, void * >	m_resources
GLint	max_texture_size
uint	ownsEglContext: 1
QPaintDevice *	paintDevice
void *	pbuf
int	pixelFormatId
QGLContext *	q_ptr
HGLRC	rc
QGLFormat	reqFormat
int	screen
uint	sharing: 1
QGLTextureDestroyer *	texture_destroyer
Qt::HANDLE	threadId
QColor	transpColor
bool	update
uint	valid: 1
QGLFormat::OpenGLVersionFlags	version_flags
uint	version_flags_cached: 1
bool	vertexAttributeArraysEnabledState [QT_GL_VERTEX_ARRAY_TRACKED_COUNT]
void *	vi
WId	win
uint	workaround_brokenAlphaTexSubImage: 1
uint	workaround_brokenAlphaTexSubImage_init: 1
uint	workaround_brokenFBOReadBack: 1
uint	workaround_brokenScissor: 1
uint	workaround_brokenTexSubImage: 1
uint	workaround_brokenTextureFromPixmap: 1
uint	workaround_brokenTextureFromPixmap_init: 1
uint	workaround_needsFullClearOnEveryFrame: 1
uint	workaroundsCached: 1

Static Public Variables
static QEglProperties *	extraWindowSurfaceCreationProps = NULL
static Q_OPENGL_EXPORT QGLExtensionFuncs	qt_extensionFuncs

Detailed Description

Definition at line 347 of file qgl_p.h.

Constructors and Destructors

QGLContextPrivate()

QGLContextPrivate::QGLContextPrivate ( QGLContext *  context )

explicit

Definition at line 1728 of file qgl.cpp.

    : internal_context(false)
    , q_ptr(context)
{
    group = new QGLContextGroup(context);
    texture_destroyer = new QGLTextureDestroyer;
    texture_destroyer->moveToThread(qApp->thread());
}

~QGLContextPrivate()

QGLContextPrivate::~QGLContextPrivate

(

)

Definition at line 1737 of file qgl.cpp.

{
    if (!group->m_refs.deref()) {
        Q_ASSERT(group->context() == q_ptr);
        delete group;
    }

    delete texture_destroyer;
}

Functions

bindTexture() [1/3]

QGLTexture * QGLContextPrivate::bindTexture	(	const QImage &	image,
		GLenum	target,
		GLint	format,
		QGLContext::BindOptions	options
	)

Warning

This function is not part of the public interface.

Definition at line 2394 of file qgl.cpp.

{
    Q_Q(QGLContext);

    const qint64 key = image.cacheKey();
    QGLTexture *texture = textureCacheLookup(key, target);
    if (texture) {
        if (image.paintingActive()) {
            // A QPainter is active on the image - take the safe route and replace the texture.
            q->deleteTexture(texture->id);
            texture = 0;
        } else {
            glBindTexture(target, texture->id);
            return texture;
        }
    }

    if (!texture)
        texture = bindTexture(image, target, format, key, options);
    // NOTE: bindTexture(const QImage&, GLenum, GLint, const qint64, bool) should never return null
    Q_ASSERT(texture);

    // Enable the cleanup hooks for this image so that the texture cache entry is removed when the
    // image gets deleted:
    QImagePixmapCleanupHooks::enableCleanupHooks(image);

    return texture;
}

bindTexture() [2/3]

QGLTexture * QGLContextPrivate::bindTexture	(	const QImage &	image,
		GLenum	target,
		GLint	format,
		const qint64	key,
		QGLContext::BindOptions	options
	)

Definition at line 2449 of file qgl.cpp.

{
    Q_Q(QGLContext);

#ifdef QGL_BIND_TEXTURE_DEBUG
    printf("QGLContextPrivate::bindTexture(), imageSize=(%d,%d), internalFormat =0x%x, options=%x, key=%llx\n",
           image.width(), image.height(), internalFormat, int(options), key);
    QTime time;
    time.start();
#endif

#ifndef QT_NO_DEBUG
    // Reset the gl error stack...git
    while (glGetError() != GL_NO_ERROR) ;
#endif

    // Scale the pixmap if needed. GL textures needs to have the
    // dimensions 2^n+2(border) x 2^m+2(border), unless we're using GL
    // 2.0 or use the GL_TEXTURE_RECTANGLE texture target
    int tx_w = qt_next_power_of_two(image.width());
    int tx_h = qt_next_power_of_two(image.height());

    QImage img = image;

    if (!(QGLExtensions::glExtensions() & QGLExtensions::NPOTTextures)
        && !(QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_ES_Version_2_0)
        && (target == GL_TEXTURE_2D && (tx_w != image.width() || tx_h != image.height())))
    {
        img = img.scaled(tx_w, tx_h);
#ifdef QGL_BIND_TEXTURE_DEBUG
        printf(" - upscaled to %dx%d (%d ms)\n", tx_w, tx_h, time.elapsed());

#endif
    }

    GLuint filtering = options & QGLContext::LinearFilteringBindOption ? GL_LINEAR : GL_NEAREST;

    GLuint tx_id;
    glGenTextures(1, &tx_id);
    glBindTexture(target, tx_id);
    glTexParameterf(target, GL_TEXTURE_MAG_FILTER, filtering);

#if defined(QT_OPENGL_ES_2)
    bool genMipmap = false;
#endif
    if (glFormat.directRendering()
        && (QGLExtensions::glExtensions() & QGLExtensions::GenerateMipmap)
        && target == GL_TEXTURE_2D
        && (options & QGLContext::MipmapBindOption))
    {
#if !defined(QT_OPENGL_ES_2)
        glHint(GL_GENERATE_MIPMAP_HINT_SGIS, GL_NICEST);
#ifndef QT_OPENGL_ES
        glTexParameteri(target, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
#else
        glTexParameterf(target, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
#endif
#else
        glHint(GL_GENERATE_MIPMAP_HINT, GL_NICEST);
        genMipmap = true;
#endif
        glTexParameterf(target, GL_TEXTURE_MIN_FILTER, options & QGLContext::LinearFilteringBindOption
                        ? GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST);
#ifdef QGL_BIND_TEXTURE_DEBUG
        printf(" - generating mipmaps (%d ms)\n", time.elapsed());
#endif
    } else {
        glTexParameterf(target, GL_TEXTURE_MIN_FILTER, filtering);
    }

    QImage::Format target_format = img.format();
    bool premul = options & QGLContext::PremultipliedAlphaBindOption;
    GLenum externalFormat;
    GLuint pixel_type;
    if (QGLExtensions::glExtensions() & QGLExtensions::BGRATextureFormat) {
        externalFormat = GL_BGRA;
        if (QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2)
            pixel_type = GL_UNSIGNED_INT_8_8_8_8_REV;
        else
            pixel_type = GL_UNSIGNED_BYTE;
    } else {
        externalFormat = GL_RGBA;
        pixel_type = GL_UNSIGNED_BYTE;
    }

    switch (target_format) {
    case QImage::Format_ARGB32:
        if (premul) {
            img = img.convertToFormat(target_format = QImage::Format_ARGB32_Premultiplied);
#ifdef QGL_BIND_TEXTURE_DEBUG
            printf(" - converted ARGB32 -> ARGB32_Premultiplied (%d ms) \n", time.elapsed());
#endif
        }
        break;
    case QImage::Format_ARGB32_Premultiplied:
        if (!premul) {
            img = img.convertToFormat(target_format = QImage::Format_ARGB32);
#ifdef QGL_BIND_TEXTURE_DEBUG
            printf(" - converted ARGB32_Premultiplied -> ARGB32 (%d ms)\n", time.elapsed());
#endif
        }
        break;
    case QImage::Format_RGB16:
        pixel_type = GL_UNSIGNED_SHORT_5_6_5;
        externalFormat = GL_RGB;
        internalFormat = GL_RGB;
        break;
    case QImage::Format_RGB32:
        break;
    default:
        if (img.hasAlphaChannel()) {
            img = img.convertToFormat(premul
                                      ? QImage::Format_ARGB32_Premultiplied
                                      : QImage::Format_ARGB32);
#ifdef QGL_BIND_TEXTURE_DEBUG
            printf(" - converted to 32-bit alpha format (%d ms)\n", time.elapsed());
#endif
        } else {
            img = img.convertToFormat(QImage::Format_RGB32);
#ifdef QGL_BIND_TEXTURE_DEBUG
            printf(" - converted to 32-bit (%d ms)\n", time.elapsed());
#endif
        }
    }

    if (options & QGLContext::InvertedYBindOption) {
        if (img.isDetached()) {
            int ipl = img.bytesPerLine() / 4;
            int h = img.height();
            for (int y=0; y<h/2; ++y) {
                int *a = (int *) img.scanLine(y);
                int *b = (int *) img.scanLine(h - y - 1);
                for (int x=0; x<ipl; ++x)
                    qSwap(a[x], b[x]);
            }
        } else {
            // Create a new image and copy across.  If we use the
            // above in-place code then a full copy of the image is
            // made before the lines are swapped, which processes the
            // data twice.  This version should only do it once.
            img = img.mirrored();
        }
#ifdef QGL_BIND_TEXTURE_DEBUG
            printf(" - flipped bits over y (%d ms)\n", time.elapsed());
#endif
    }

    if (externalFormat == GL_RGBA) {
        // The only case where we end up with a depth different from
        // 32 in the switch above is for the RGB16 case, where we set
        // the format to GL_RGB
        Q_ASSERT(img.depth() == 32);
        qgl_byteSwapImage(img, pixel_type);
#ifdef QGL_BIND_TEXTURE_DEBUG
            printf(" - did byte swapping (%d ms)\n", time.elapsed());
#endif
    }
#ifdef QT_OPENGL_ES
    // OpenGL/ES requires that the internal and external formats be
    // identical.
    internalFormat = externalFormat;
#endif
#ifdef QGL_BIND_TEXTURE_DEBUG
    printf(" - uploading, image.format=%d, externalFormat=0x%x, internalFormat=0x%x, pixel_type=0x%x\n",
           img.format(), externalFormat, internalFormat, pixel_type);
#endif

    const QImage &constRef = img; // to avoid detach in bits()...
#ifdef Q_OS_SYMBIAN
    // On Symbian we always use texture pool to reserve the texture
    QGLTexturePool::instance()->createPermanentTexture(tx_id,
                                                        target,
                                                        0, internalFormat,
                                                        img.width(), img.height(),
                                                        externalFormat,
                                                        pixel_type,
                                                        constRef.bits());
#else
    glTexImage2D(target, 0, internalFormat, img.width(), img.height(), 0, externalFormat,
                 pixel_type, constRef.bits());
#endif

#if defined(QT_OPENGL_ES_2)
    if (genMipmap)
        glGenerateMipmap(target);
#endif
#ifndef QT_NO_DEBUG
    GLenum error = glGetError();
    if (error != GL_NO_ERROR) {
        qWarning(" - texture upload failed, error code 0x%x, enum: %d (%x)\n", error, target, target);
    }
#endif

#ifdef QGL_BIND_TEXTURE_DEBUG
    static int totalUploadTime = 0;
    totalUploadTime += time.elapsed();
    printf(" - upload done in %d ms, (accumulated: %d ms)\n", time.elapsed(), totalUploadTime);
#endif


    // this assumes the size of a texture is always smaller than the max cache size
    int cost = img.width()*img.height()*4/1024;
    QGLTexture *texture = new QGLTexture(q, tx_id, target, options);
    QGLTextureCache::instance()->insert(q, key, texture, cost);

#ifdef Q_OS_SYMBIAN
    // Store the key so that QGLTexturePool
    // is able to release this texture when needed.
    texture->boundKey = key;
    // And append to LRU list
    QGLTexturePool::instance()->useTexture(texture);
#endif
    return texture;
}

bindTexture() [3/3]

QGLTexture * QGLContextPrivate::bindTexture	(	const QPixmap &	pixmap,
		GLenum	target,
		GLint	format,
		QGLContext::BindOptions	options
	)

Warning

This function is not part of the public interface.

Definition at line 2678 of file qgl.cpp.

{
    Q_Q(QGLContext);
    QPixmapData *pd = pixmap.pixmapData();
#if !defined(QT_OPENGL_ES_1)
    if (target == GL_TEXTURE_2D && pd->classId() == QPixmapData::OpenGLClass) {
        const QGLPixmapData *data = static_cast<const QGLPixmapData *>(pd);

        if (data->isValidContext(q)) {
            data->bind();
            return data->texture();
        }
    }
#else
    Q_UNUSED(pd);
#endif

    const qint64 key = pixmap.cacheKey();
    QGLTexture *texture = textureCacheLookup(key, target);
    if (texture) {
        if (pixmap.paintingActive()) {
            // A QPainter is active on the pixmap - take the safe route and replace the texture.
            q->deleteTexture(texture->id);
            texture = 0;
        } else {
            glBindTexture(target, texture->id);
            return texture;
        }
    }

#if defined(Q_WS_X11)
    // Try to use texture_from_pixmap
    const QX11Info *xinfo = qt_x11Info(paintDevice);
    if (pd->classId() == QPixmapData::X11Class && pd->pixelType() == QPixmapData::PixmapType
        && xinfo && xinfo->screen() == pixmap.x11Info().screen()
        && target == GL_TEXTURE_2D
        && QApplication::instance()->thread() == QThread::currentThread())
    {
        if (!workaround_brokenTextureFromPixmap_init) {
            workaround_brokenTextureFromPixmap_init = true;

            const QByteArray versionString(reinterpret_cast<const char*>(glGetString(GL_VERSION)));
            const int pos = versionString.indexOf("NVIDIA ");

            if (pos >= 0) {
                const QByteArray nvidiaVersionString = versionString.mid(pos + strlen("NVIDIA "));

                if (nvidiaVersionString.startsWith("195") || nvidiaVersionString.startsWith("256"))
                    workaround_brokenTextureFromPixmap = true;
            }
        }

        if (!workaround_brokenTextureFromPixmap) {
            texture = bindTextureFromNativePixmap(const_cast<QPixmap*>(&pixmap), key, options);
            if (texture) {
                texture->options |= QGLContext::MemoryManagedBindOption;
                texture->boundPixmap = pd;
                boundPixmaps.insert(pd, QPixmap(pixmap));
            }
        }
    }
#endif

    if (!texture) {
#ifdef Q_OS_SYMBIAN
        // On Symbian pixmaps are backed up by native CFbsBitmap
        // which can be shared across processes. QVolatileImage wraps
        // it and provides locking mechanism to pixel access.
        QVolatileImage volatileImage = pd->toVolatileImage();
        if (volatileImage.isNull()) { // TODO: raster graphics system don't provide volatile image (yet)
            // NOTE! On Symbian raster graphics system QPixmap::toImage() makes deep copy
            texture = bindTexture(pixmap.toImage(), target, format, key, options);
        } else {
            volatileImage.beginDataAccess();
            texture = bindTexture(volatileImage.imageRef(), target, format, key, options);
            volatileImage.endDataAccess(true);
        }
#else
        QImage image = pixmap.toImage();
        // If the system depth is 16 and the pixmap doesn't have an alpha channel
        // then we convert it to RGB16 in the hope that it gets uploaded as a 16
        // bit texture which is much faster to access than a 32-bit one.
        if (pixmap.depth() == 16 && !image.hasAlphaChannel() )
            image = image.convertToFormat(QImage::Format_RGB16);
        texture = bindTexture(image, target, format, key, options);
#endif
    }
    // NOTE: bindTexture(const QImage&, GLenum, GLint, const qint64, bool) should never return null
    Q_ASSERT(texture);

    if (texture->id > 0)
        QImagePixmapCleanupHooks::enableCleanupHooks(pixmap);

    return texture;
}

bindTextureFromNativePixmap()

QGLTexture * QGLContextPrivate::bindTextureFromNativePixmap	(	QPixmap *	pixmap,
		const qint64	key,
		QGLContext::BindOptions	options
	)

defined(GLX_VERSION_1_3) || defined(Q_OS_HPUX)

Definition at line 1765 of file qgl_x11.cpp.

{
#if !defined(GLX_VERSION_1_3) || defined(Q_OS_HPUX)
    return 0;
#else

    // Check we have GLX 1.3, as it is needed for glXCreatePixmap & glXDestroyPixmap
    int majorVersion = 0;
    int minorVersion = 0;
    glXQueryVersion(X11->display, &majorVersion, &minorVersion);
    if (majorVersion < 1 || (majorVersion == 1 && minorVersion < 3))
        return 0;

    Q_Q(QGLContext);

    QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pixmap->data_ptr().data());
    Q_ASSERT(pixmapData->classId() == QPixmapData::X11Class);

    // We can't use TFP if the pixmap has a separate X11 mask
    if (pixmapData->x11_mask)
        return 0;

    if (!qt_resolveTextureFromPixmap(paintDevice))
        return 0;

    const QX11Info &x11Info = pixmapData->xinfo;

    // Store the configs (Can be static because configs aren't dependent on current context)
    static GLXFBConfig glxRGBPixmapConfig = 0;
    static bool RGBConfigInverted = false;
    static GLXFBConfig glxRGBAPixmapConfig = 0;
    static bool RGBAConfigInverted = false;

    bool hasAlpha = pixmapData->hasAlphaChannel();

    // Check to see if we need a config
    if ( (hasAlpha && !glxRGBAPixmapConfig) || (!hasAlpha && !glxRGBPixmapConfig) ) {
        GLXFBConfig    *configList = 0;
        int             configCount = 0;

        int configAttribs[] = {
            hasAlpha ? GLX_BIND_TO_TEXTURE_RGBA_EXT : GLX_BIND_TO_TEXTURE_RGB_EXT, True,
            GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
            GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT,
            // QGLContext::bindTexture() can't return an inverted texture, but QPainter::drawPixmap() can:
            GLX_Y_INVERTED_EXT, int(options & QGLContext::CanFlipNativePixmapBindOption ? GLX_DONT_CARE : False),
            XNone
        };
        configList = glXChooseFBConfig(x11Info.display(), x11Info.screen(), configAttribs, &configCount);
        if (!configList)
            return 0;

        int yInv;
        glXGetFBConfigAttrib(x11Info.display(), configList[0], GLX_Y_INVERTED_EXT, &yInv);

        if (hasAlpha) {
            glxRGBAPixmapConfig = configList[0];
            RGBAConfigInverted = yInv;
        }
        else {
            glxRGBPixmapConfig = configList[0];
            RGBConfigInverted = yInv;
        }

        XFree(configList);
    }

    // Check to see if the surface is still valid
    if (pixmapData->gl_surface &&
        hasAlpha != (pixmapData->flags & QX11PixmapData::GlSurfaceCreatedWithAlpha))
    {
        // Surface is invalid!
        destroyGlSurfaceForPixmap(pixmapData);
    }

    // Check to see if we need a surface
    if (!pixmapData->gl_surface) {
        GLXPixmap glxPixmap;
        int pixmapAttribs[] = {
            GLX_TEXTURE_FORMAT_EXT, hasAlpha ? GLX_TEXTURE_FORMAT_RGBA_EXT : GLX_TEXTURE_FORMAT_RGB_EXT,
            GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
            GLX_MIPMAP_TEXTURE_EXT, False, // Maybe needs to be don't care
            XNone
        };

        // Wrap the X Pixmap into a GLXPixmap:
        glxPixmap = glXCreatePixmap(x11Info.display(),
                                    hasAlpha ? glxRGBAPixmapConfig : glxRGBPixmapConfig,
                                    pixmapData->handle(), pixmapAttribs);

        if (!glxPixmap)
            return 0;

        pixmapData->gl_surface = (void*)glxPixmap;

        // Make sure the cleanup hook gets called so we can delete the glx pixmap
        QImagePixmapCleanupHooks::enableCleanupHooks(pixmapData);
    }

    GLuint textureId;
    glGenTextures(1, &textureId);
    glBindTexture(GL_TEXTURE_2D, textureId);
    glXBindTexImageEXT(x11Info.display(), (GLXPixmap)pixmapData->gl_surface, GLX_FRONT_LEFT_EXT, 0);

    glBindTexture(GL_TEXTURE_2D, textureId);
    GLuint filtering = (options & QGLContext::LinearFilteringBindOption) ? GL_LINEAR : GL_NEAREST;
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);

    if (!((hasAlpha && RGBAConfigInverted) || (!hasAlpha && RGBConfigInverted)))
        options &= ~QGLContext::InvertedYBindOption;

    QGLTexture *texture = new QGLTexture(q, textureId, GL_TEXTURE_2D, options);
    if (texture->options & QGLContext::InvertedYBindOption)
        pixmapData->flags |= QX11PixmapData::InvertedWhenBoundToTexture;

    // We assume the cost of bound pixmaps is zero
    QGLTextureCache::instance()->insert(q, key, texture, 0);

    return texture;
#endif 
}

cleanup()

void QGLContextPrivate::cleanup

(

)

Definition at line 2180 of file qgl.cpp.

{
    QHash<QGLContextResourceBase *, void *>::ConstIterator it;
    for (it = m_resources.begin(); it != m_resources.end(); ++it)
        it.key()->freeResource(it.value());
    m_resources.clear();
}

clearDrawable()

void QGLContextPrivate::clearDrawable

(

)

Definition at line 473 of file qgl_mac.mm.

{
    [static_cast<NSOpenGLContext *>(cx) clearDrawable];
}

contextGroup()

static QGLContextGroup* QGLContextPrivate::contextGroup ( const QGLContext *  ctx )

inlinestatic

Definition at line 464 of file qgl_p.h.

Referenced by QGLFramebufferObject::bind(), QGLFBOGLPaintDevice::context(), QGL2PaintEngineExPrivate::drawCachedGlyphs(), QGLTextureCache::getTexture(), and QGLFramebufferObject::release().

{ return ctx->d_ptr->group; }

convertToGLFormat()

QImage QGLContextPrivate::convertToGLFormat	(	const QImage &	image,
		bool	force_premul,
		GLenum	texture_format
	)

Definition at line 2381 of file qgl.cpp.

{
    QImage::Format target_format = image.format();
    if (force_premul || image.format() != QImage::Format_ARGB32)
        target_format = QImage::Format_ARGB32_Premultiplied;

    QImage result(image.width(), image.height(), target_format);
    convertToGLFormatHelper(result, image.convertToFormat(target_format), texture_format);
    return result;
}

destroyEglSurfaceForDevice()

void QGLContextPrivate::destroyEglSurfaceForDevice

(

)

Definition at line 296 of file qgl_egl.cpp.

{
    if (eglSurface != EGL_NO_SURFACE) {
#if defined(Q_WS_X11) || defined(Q_OS_SYMBIAN)
        // Make sure we don't call eglDestroySurface on a surface which
        // was created for a different winId. This applies only to QGLWidget
        // paint device, so make sure this is the one we're operating on
        // (as opposed to a QGLWindowSurface use case).
        if (paintDevice && paintDevice->devType() == QInternal::Widget) {
            QWidget *w = static_cast<QWidget *>(paintDevice);
            if (QGLWidget *wgl = qobject_cast<QGLWidget *>(w)) {
                if (wgl->d_func()->eglSurfaceWindowId != wgl->winId()) {
                    qWarning("WARNING: Potential EGL surface leak! Not destroying surface.");
                    eglSurface = EGL_NO_SURFACE;
                    return;
                }
            }
        }
#endif
        eglDestroySurface(eglContext->display(), eglSurface);
        eglSurface = EGL_NO_SURFACE;
    }
}

destroyGlSurfaceForPixmap()

void QGLContextPrivate::destroyGlSurfaceForPixmap ( QPixmapData *  pmd )

static

Definition at line 1890 of file qgl_x11.cpp.

{
#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
    Q_ASSERT(pmd->classId() == QPixmapData::X11Class);
    QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);
    if (pixmapData->gl_surface) {
        glXDestroyPixmap(QX11Info::display(), (GLXPixmap)pixmapData->gl_surface);
        pixmapData->gl_surface = 0;
    }
#endif
}

eglSurfaceForDevice()

EGLSurface QGLContextPrivate::eglSurfaceForDevice

(

)

const

Definition at line 320 of file qgl_egl.cpp.

{
    // If a QPixmapData had to create the QGLContext, we don't have a paintDevice
    if (!paintDevice)
        return eglSurface;

#ifdef Q_WS_X11
    if (paintDevice->devType() == QInternal::Pixmap) {
        QPixmapData *pmd = static_cast<QPixmap*>(paintDevice)->data_ptr().data();
        if (pmd->classId() == QPixmapData::X11Class) {
            QX11PixmapData* x11PixmapData = static_cast<QX11PixmapData*>(pmd);
            return (EGLSurface)x11PixmapData->gl_surface;
        }
    }
#endif

    if (paintDevice->devType() == QInternal::Pbuffer) {
        QGLPixelBuffer* pbuf = static_cast<QGLPixelBuffer*>(paintDevice);
        return pbuf->d_func()->pbuf;
    }

    return eglSurface;
}

extensionFuncs() [1/2]

QGLExtensionFuncs & QGLContextPrivate::extensionFuncs ( const QGLContext *  ctx )

inlinestatic

Definition at line 467 of file qgl_p.h.

Referenced by qt_resolve_buffer_extensions(), and qt_resolve_glsl_extensions().

{ return ctx->d_ptr->group->extensionFuncs(); }

extensionFuncs() [2/2]

static Q_OPENGL_EXPORT QGLExtensionFuncs& QGLContextPrivate::extensionFuncs ( const QGLContext *  )

static

init()

void QGLContextPrivate::init	(	QPaintDevice *	dev,
		const QGLFormat &	format
	)

Definition at line 1747 of file qgl.cpp.

{
    Q_Q(QGLContext);
    glFormat = reqFormat = format;
    valid = false;
    q->setDevice(dev);
#if defined(Q_WS_X11)
    pbuf = 0;
    gpm = 0;
    vi = 0;
    screen = QX11Info::appScreen();
#endif
#if defined(Q_WS_WIN)
    dc = 0;
    win = 0;
    threadId = 0;
    pixelFormatId = 0;
    cmap = 0;
    hbitmap = 0;
    hbitmap_hdc = 0;
#endif
#if defined(Q_WS_MAC)
#  ifndef QT_MAC_USE_COCOA
    update = false;
#  endif
    vi = 0;
#endif
#if defined(Q_WS_QPA)
    platformContext = 0;
#endif
#if !defined(QT_NO_EGL)
    ownsEglContext = false;
    eglContext = 0;
    eglSurface = EGL_NO_SURFACE;
#endif
    fbo = 0;
    crWin = false;
    initDone = false;
    sharing = false;
    max_texture_size = -1;
    version_flags_cached = false;
    version_flags = QGLFormat::OpenGL_Version_None;
    extension_flags_cached = false;
    extension_flags = 0;
    current_fbo = 0;
    default_fbo = 0;
    active_engine = 0;
    workaround_needsFullClearOnEveryFrame = false;
    workaround_brokenFBOReadBack = false;
    workaround_brokenTexSubImage = false;
    workaroundsCached = false;

    workaround_brokenTextureFromPixmap = false;
    workaround_brokenTextureFromPixmap_init = false;

    workaround_brokenScissor = false;
    workaround_brokenAlphaTexSubImage = false;
    workaround_brokenAlphaTexSubImage_init = false;

    for (int i = 0; i < QT_GL_VERTEX_ARRAY_TRACKED_COUNT; ++i)
        vertexAttributeArraysEnabledState[i] = false;
}

maxTextureSize()

int QGLContextPrivate::maxTextureSize

(

)

Warning

This function is not part of the public interface.

Definition at line 2775 of file qgl.cpp.

Referenced by QGLTextureGlyphCache::maxTextureHeight(), and QGLTextureGlyphCache::maxTextureWidth().

{
    if (max_texture_size != -1)
        return max_texture_size;

    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);

#if defined(QT_OPENGL_ES)
    return max_texture_size;
#else
    GLenum proxy = GL_PROXY_TEXTURE_2D;

    GLint size;
    GLint next = 64;
    glTexImage2D(proxy, 0, GL_RGBA, next, next, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
    glGetTexLevelParameteriv(proxy, 0, GL_TEXTURE_WIDTH, &size);
    if (size == 0) {
        return max_texture_size;
    }
    do {
        size = next;
        next = size * 2;

        if (next > max_texture_size)
            break;
        glTexImage2D(proxy, 0, GL_RGBA, next, next, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
        glGetTexLevelParameteriv(proxy, 0, GL_TEXTURE_WIDTH, &next);
    } while (next > size);

    max_texture_size = size;
    return max_texture_size;
#endif
}

setCurrentContext()

void QGLContextPrivate::setCurrentContext ( QGLContext *  context )

static

Definition at line 3577 of file qgl.cpp.

Referenced by QGLContext::chooseMacVisual(), QGLContext::choosePixelFormat(), QGLContext::doneCurrent(), QGLContext::makeCurrent(), QGLContext::tryVisual(), and QGLContext::updatePaintDevice().

{
#ifdef Q_WS_QPA
    Q_UNUSED(context);
#else
    QGLThreadContext *threadContext = qgl_context_storage.localData();
    if (!threadContext) {
        if (!QThread::currentThread()) {
            // We don't have a current QThread, so just set the static.
            QGLContext::currentCtx = context;
            return;
        }
        threadContext = new QGLThreadContext;
        qgl_context_storage.setLocalData(threadContext);
    }
    threadContext->context = context;
    QGLContext::currentCtx = context; // XXX: backwards-compat, not thread-safe
#endif
}

setExtraWindowSurfaceCreationProps()

void QGLContextPrivate::setExtraWindowSurfaceCreationProps ( QEglProperties *  props )

static

Definition at line 352 of file qgl_egl.cpp.

Referenced by QMeeGoGraphicsSystem::setSurfaceFixedSize().

{
    extraWindowSurfaceCreationProps = props;
}

setVertexAttribArrayEnabled()

void QGLContextPrivate::setVertexAttribArrayEnabled	(	int	arrayIndex,
		bool	enabled = true
	)

Definition at line 2189 of file qgl.cpp.

Referenced by QGLEngineShaderManager::useBlitProgram(), QGLEngineShaderManager::useCorrectShaderProg(), and QGLEngineShaderManager::useSimpleProgram().

{
    Q_ASSERT(arrayIndex < QT_GL_VERTEX_ARRAY_TRACKED_COUNT);
#ifdef glEnableVertexAttribArray
    Q_ASSERT(glEnableVertexAttribArray);
#endif

    if (vertexAttributeArraysEnabledState[arrayIndex] && !enabled)
        glDisableVertexAttribArray(arrayIndex);

    if (!vertexAttributeArraysEnabledState[arrayIndex] && enabled)
        glEnableVertexAttribArray(arrayIndex);

    vertexAttributeArraysEnabledState[arrayIndex] = enabled;
}

swapRegion()

void QGLContextPrivate::swapRegion

(

const QRegion &

region

)

Definition at line 344 of file qgl_egl.cpp.

{
    if (!valid || !eglContext)
        return;

    eglContext->swapBuffersRegion2NOK(eglSurfaceForDevice(), &region);
}

syncGlState()

void QGLContextPrivate::syncGlState

(

)

Definition at line 2205 of file qgl.cpp.

{
#ifdef glEnableVertexAttribArray
    Q_ASSERT(glEnableVertexAttribArray);
#endif
    for (int i = 0; i < QT_GL_VERTEX_ARRAY_TRACKED_COUNT; ++i) {
        if (vertexAttributeArraysEnabledState[i])
            glEnableVertexAttribArray(i);
        else
            glDisableVertexAttribArray(i);
    }

}

textureCacheLookup()

QGLTexture * QGLContextPrivate::textureCacheLookup	(	const qint64	key,
		GLenum	target
	)

Definition at line 2665 of file qgl.cpp.

{
    Q_Q(QGLContext);
    QGLTexture *texture = QGLTextureCache::instance()->getTexture(q, key);
    if (texture && texture->target == target
        && (texture->context == q || QGLContext::areSharing(q, texture->context)))
    {
        return texture;
    }
    return 0;
}

tryFormat()

void * QGLContextPrivate::tryFormat

(

const QGLFormat &

format

)

Definition at line 351 of file qgl_mac.mm.

{
    static const int Max = 40;
#ifndef QT_MAC_USE_COCOA
    GLint attribs[Max], cnt = 0;
    bool device_is_pixmap = (paintDevice->devType() == QInternal::Pixmap);

    attribs[cnt++] = AGL_RGBA;
    attribs[cnt++] = AGL_BUFFER_SIZE;
    attribs[cnt++] = device_is_pixmap ? static_cast<QPixmap *>(paintDevice)->depth() : 32;
    attribs[cnt++] = AGL_LEVEL;
    attribs[cnt++] = format.plane();

    if (format.redBufferSize() != -1) {
        attribs[cnt++] = AGL_RED_SIZE;
        attribs[cnt++] = format.redBufferSize();
    }
    if (format.greenBufferSize() != -1) {
        attribs[cnt++] = AGL_GREEN_SIZE;
        attribs[cnt++] = format.greenBufferSize();
    }
    if (format.blueBufferSize() != -1) {
        attribs[cnt++] = AGL_BLUE_SIZE;
        attribs[cnt++] = format.blueBufferSize();
    }
    if (device_is_pixmap) {
        attribs[cnt++] = AGL_PIXEL_SIZE;
        attribs[cnt++] = static_cast<QPixmap *>(paintDevice)->depth();
        attribs[cnt++] = AGL_OFFSCREEN;
        if (!format.alpha()) {
            attribs[cnt++] = AGL_ALPHA_SIZE;
            attribs[cnt++] = 8;
        }
    } else {
        if (format.doubleBuffer())
            attribs[cnt++] = AGL_DOUBLEBUFFER;
    }

    if (format.stereo())
        attribs[cnt++] = AGL_STEREO;
    if (format.alpha()) {
        attribs[cnt++] = AGL_ALPHA_SIZE;
        attribs[cnt++] = format.alphaBufferSize() == -1 ? 8 : format.alphaBufferSize();
    }
    if (format.stencil()) {
        attribs[cnt++] = AGL_STENCIL_SIZE;
        attribs[cnt++] = format.stencilBufferSize() == -1 ? 8 : format.stencilBufferSize();
    }
    if (format.depth()) {
        attribs[cnt++] = AGL_DEPTH_SIZE;
        attribs[cnt++] = format.depthBufferSize() == -1 ? 32 : format.depthBufferSize();
    }
    if (format.accum()) {
        attribs[cnt++] = AGL_ACCUM_RED_SIZE;
        attribs[cnt++] = format.accumBufferSize() == -1 ? 1 : format.accumBufferSize();
        attribs[cnt++] = AGL_ACCUM_BLUE_SIZE;
        attribs[cnt++] = format.accumBufferSize() == -1 ? 1 : format.accumBufferSize();
        attribs[cnt++] = AGL_ACCUM_GREEN_SIZE;
        attribs[cnt++] = format.accumBufferSize() == -1 ? 1 : format.accumBufferSize();
        attribs[cnt++] = AGL_ACCUM_ALPHA_SIZE;
        attribs[cnt++] = format.accumBufferSize() == -1 ? 1 : format.accumBufferSize();
    }
    if (format.sampleBuffers()) {
        attribs[cnt++] = AGL_SAMPLE_BUFFERS_ARB;
        attribs[cnt++] = 1;
        attribs[cnt++] = AGL_SAMPLES_ARB;
        attribs[cnt++] = format.samples() == -1 ? 4 : format.samples();
    }

    attribs[cnt] = AGL_NONE;
    Q_ASSERT(cnt < Max);
    return aglChoosePixelFormat(0, 0, attribs);
#else
    NSOpenGLPixelFormatAttribute attribs[Max];
    int cnt = 0;
    int devType = paintDevice->devType();
    bool device_is_pixmap = (devType == QInternal::Pixmap);
    int depth = device_is_pixmap ? static_cast<QPixmap *>(paintDevice)->depth() : 32;

    attribs[cnt++] = NSOpenGLPFAColorSize;
    attribs[cnt++] = depth;

    if (device_is_pixmap) {
        attribs[cnt++] = NSOpenGLPFAOffScreen;
    } else {
        if (format.doubleBuffer())
            attribs[cnt++] = NSOpenGLPFADoubleBuffer;
    }
    if (glFormat.stereo())
        attribs[cnt++] = NSOpenGLPFAStereo;
    if (device_is_pixmap || format.alpha()) {
        attribs[cnt++] = NSOpenGLPFAAlphaSize;
        attribs[cnt++] = def(format.alphaBufferSize(), 8);
    }
    if (format.stencil()) {
        attribs[cnt++] = NSOpenGLPFAStencilSize;
        attribs[cnt++] = def(format.stencilBufferSize(), 8);
    }
    if (format.depth()) {
        attribs[cnt++] = NSOpenGLPFADepthSize;
        attribs[cnt++] = def(format.depthBufferSize(), 32);
    }
    if (format.accum()) {
        attribs[cnt++] = NSOpenGLPFAAccumSize;
        attribs[cnt++] = def(format.accumBufferSize(), 1);
    }
    if (format.sampleBuffers()) {
        attribs[cnt++] = NSOpenGLPFASampleBuffers;
        attribs[cnt++] = 1;
        attribs[cnt++] = NSOpenGLPFASamples;
        attribs[cnt++] = def(format.samples(), 4);
    }

    if (devType == QInternal::Pbuffer)
        attribs[cnt++] = NSOpenGLPFAPixelBuffer;

    attribs[cnt] = 0;
    Q_ASSERT(cnt < Max);
    return [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs];
#endif
}

unbindPixmapFromTexture()

void QGLContextPrivate::unbindPixmapFromTexture ( QPixmapData *  pmd )

static

Definition at line 1902 of file qgl_x11.cpp.

Referenced by QGLTextureDestroyer::freeTexture_slot().

{
#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
    Q_ASSERT(pmd->classId() == QPixmapData::X11Class);
    Q_ASSERT(QGLContext::currentContext());
    QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);
    if (pixmapData->gl_surface)
        glXReleaseTexImageEXT(QX11Info::display(), (GLXPixmap)pixmapData->gl_surface, GLX_FRONT_LEFT_EXT);
#endif
}

updateFormatVersion()

void QGLContextPrivate::updateFormatVersion

(

)

Definition at line 770 of file qgl_win.cpp.

{
    const GLubyte *s = glGetString(GL_VERSION);

    if (!(s && s[0] >= '0' && s[0] <= '9' && s[1] == '.' && s[2] >= '0' && s[2] <= '9')) {
        if (!s)
            qWarning("QGLContext::chooseContext(): OpenGL version string is null.");
        else
            qWarning("QGLContext::chooseContext(): Unexpected OpenGL version string format.");
        glFormat.setVersion(0, 0);
        glFormat.setProfile(QGLFormat::NoProfile);
        glFormat.setOption(QGL::DeprecatedFunctions);
        return;
    }

    int major = s[0] - '0';
    int minor = s[2] - '0';
    glFormat.setVersion(major, minor);

    if (major < 3) {
        glFormat.setProfile(QGLFormat::NoProfile);
        glFormat.setOption(QGL::DeprecatedFunctions);
    } else {
        GLint value = 0;
        if (major > 3 || minor >= 2)
            glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &value);

        switch (value) {
        case WGL_CONTEXT_CORE_PROFILE_BIT_ARB:
            glFormat.setProfile(QGLFormat::CoreProfile);
            break;
        case WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB:
            glFormat.setProfile(QGLFormat::CompatibilityProfile);
            break;
        default:
            glFormat.setProfile(QGLFormat::NoProfile);
            break;
        }

        glGetIntegerv(GL_CONTEXT_FLAGS, &value);
        if (value & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
            glFormat.setOption(QGL::NoDeprecatedFunctions);
        else
            glFormat.setOption(QGL::DeprecatedFunctions);
    }
}

Properties

active_engine

QPaintEngine* QGLContextPrivate::active_engine

Definition at line 458 of file qgl_p.h.

Referenced by QGLPixmapData::copy(), and QGL2PaintEngineEx::ensureActive().

boundPixmaps

QHash<QPixmapData*, QPixmap> QGLContextPrivate::boundPixmaps

Definition at line 407 of file qgl_p.h.

cmap

QGLCmap* QGLContextPrivate::cmap

Definition at line 379 of file qgl_p.h.

crWin

uint QGLContextPrivate::crWin

Definition at line 425 of file qgl_p.h.

current_fbo

GLuint QGLContextPrivate::current_fbo

Definition at line 456 of file qgl_p.h.

Referenced by QGLPaintDevice::beginPaint(), QGLFramebufferObject::bind(), QGLFramebufferObject::bindDefault(), QGLFramebufferObject::blitFramebuffer(), QGLPixmapData::copy(), QGLPixmapData::copyBackFromRenderFbo(), QGLPaintDevice::endPaint(), QGLPaintDevice::ensureActiveTarget(), QGLWindowSurface::flush(), QGLFramebufferObjectPrivate::init(), QGLFramebufferObject::isBound(), QGLFramebufferObject::release(), and QGLTextureGlyphCache::resizeTextureData().

cx

void* QGLContextPrivate::cx

Definition at line 398 of file qgl_p.h.

dc

HDC QGLContextPrivate::dc

Definition at line 376 of file qgl_p.h.

default_fbo

GLuint QGLContextPrivate::default_fbo

Definition at line 457 of file qgl_p.h.

Referenced by QGLPaintDevice::beginPaint(), QGLFramebufferObject::bindDefault(), QGLPaintDevice::endPaint(), QGLPaintDevice::ensureActiveTarget(), and QGLFramebufferObject::release().

eglContext

QEglContext* QGLContextPrivate::eglContext

Definition at line 385 of file qgl_p.h.

eglSurface

EGLSurface QGLContextPrivate::eglSurface

Definition at line 386 of file qgl_p.h.

extension_flags

QGLExtensions::Extensions QGLContextPrivate::extension_flags

Definition at line 451 of file qgl_p.h.

extension_flags_cached

uint QGLContextPrivate::extension_flags_cached

Definition at line 428 of file qgl_p.h.

extraWindowSurfaceCreationProps

QEglProperties * QGLContextPrivate::extraWindowSurfaceCreationProps = NULL

static

Definition at line 389 of file qgl_p.h.

fbo

GLuint QGLContextPrivate::fbo

Definition at line 420 of file qgl_p.h.

Referenced by QGLPixmapData::copy(), and QGLPixmapData::copyBackFromRenderFbo().

glFormat

QGLFormat QGLContextPrivate::glFormat

Definition at line 418 of file qgl_p.h.

gpm

quint32 QGLContextPrivate::gpm

Definition at line 405 of file qgl_p.h.

group

QGLContextGroup* QGLContextPrivate::group

Definition at line 453 of file qgl_p.h.

Referenced by contextGroup(), and extensionFuncs().

hbitmap

HBITMAP QGLContextPrivate::hbitmap

Definition at line 380 of file qgl_p.h.

hbitmap_hdc

HDC QGLContextPrivate::hbitmap_hdc

Definition at line 381 of file qgl_p.h.

initDone

uint QGLContextPrivate::initDone

Definition at line 424 of file qgl_p.h.

internal_context

uint QGLContextPrivate::internal_context

Definition at line 426 of file qgl_p.h.

Referenced by QOpenGLPaintEngine::begin(), QOpenGLPaintEngine::end(), and QGLWindowSurface::updateGeometry().

m_resources

QHash<QGLContextResourceBase *, void *> QGLContextPrivate::m_resources

Definition at line 459 of file qgl_p.h.

Referenced by QGLContextResourceBase::insert(), and QGLContextResourceBase::value().

max_texture_size

GLint QGLContextPrivate::max_texture_size

Definition at line 454 of file qgl_p.h.

ownsEglContext

uint QGLContextPrivate::ownsEglContext

Definition at line 444 of file qgl_p.h.

paintDevice

QPaintDevice* QGLContextPrivate::paintDevice

Definition at line 447 of file qgl_p.h.

pbuf

void* QGLContextPrivate::pbuf

Definition at line 404 of file qgl_p.h.

pixelFormatId

int QGLContextPrivate::pixelFormatId

Definition at line 378 of file qgl_p.h.

q_ptr

QGLContext* QGLContextPrivate::q_ptr

Definition at line 449 of file qgl_p.h.

qt_extensionFuncs

QGLExtensionFuncs QGLContextPrivate::qt_extensionFuncs

static

Definition at line 471 of file qgl_p.h.

rc

HGLRC QGLContextPrivate::rc

Definition at line 375 of file qgl_p.h.

Referenced by qgl_create_context().

reqFormat

QGLFormat QGLContextPrivate::reqFormat

Definition at line 419 of file qgl_p.h.

Referenced by qgl_create_context().

screen

int QGLContextPrivate::screen

Definition at line 406 of file qgl_p.h.

sharing

uint QGLContextPrivate::sharing

Definition at line 423 of file qgl_p.h.

Referenced by qgl_create_context().

texture_destroyer

QGLTextureDestroyer* QGLContextPrivate::texture_destroyer

Definition at line 460 of file qgl_p.h.

threadId

Qt::HANDLE QGLContextPrivate::threadId

Definition at line 382 of file qgl_p.h.

transpColor

QColor QGLContextPrivate::transpColor

Definition at line 448 of file qgl_p.h.

update

bool QGLContextPrivate::update

Definition at line 414 of file qgl_p.h.

valid

uint QGLContextPrivate::valid

Definition at line 422 of file qgl_p.h.

Referenced by qgl_create_context().

version_flags

QGLFormat::OpenGLVersionFlags QGLContextPrivate::version_flags

Definition at line 450 of file qgl_p.h.

version_flags_cached

uint QGLContextPrivate::version_flags_cached

Definition at line 427 of file qgl_p.h.

vertexAttributeArraysEnabledState

bool QGLContextPrivate::vertexAttributeArraysEnabledState[QT_GL_VERTEX_ARRAY_TRACKED_COUNT]

Definition at line 462 of file qgl_p.h.

vi

void* QGLContextPrivate::vi

Definition at line 401 of file qgl_p.h.

win

WId QGLContextPrivate::win

Definition at line 377 of file qgl_p.h.

workaround_brokenAlphaTexSubImage

uint QGLContextPrivate::workaround_brokenAlphaTexSubImage

Definition at line 440 of file qgl_p.h.

Referenced by QGLTextureGlyphCache::fillTexture().

workaround_brokenAlphaTexSubImage_init

uint QGLContextPrivate::workaround_brokenAlphaTexSubImage_init

Definition at line 441 of file qgl_p.h.

Referenced by QGLTextureGlyphCache::fillTexture().

workaround_brokenFBOReadBack

uint QGLContextPrivate::workaround_brokenFBOReadBack

Definition at line 432 of file qgl_p.h.

Referenced by QGLTextureGlyphCache::createTextureData(), QGLTextureGlyphCache::fillTexture(), QGLGlyphTexture::QGLGlyphTexture(), and QGLTextureGlyphCache::resizeTextureData().

workaround_brokenScissor

uint QGLContextPrivate::workaround_brokenScissor

Definition at line 439 of file qgl_p.h.

workaround_brokenTexSubImage

uint QGLContextPrivate::workaround_brokenTexSubImage

Definition at line 433 of file qgl_p.h.

Referenced by QGLTextureGlyphCache::maxTextureHeight().

workaround_brokenTextureFromPixmap

uint QGLContextPrivate::workaround_brokenTextureFromPixmap

Definition at line 436 of file qgl_p.h.

workaround_brokenTextureFromPixmap_init

uint QGLContextPrivate::workaround_brokenTextureFromPixmap_init

Definition at line 437 of file qgl_p.h.

workaround_needsFullClearOnEveryFrame

uint QGLContextPrivate::workaround_needsFullClearOnEveryFrame

Definition at line 431 of file qgl_p.h.

workaroundsCached

uint QGLContextPrivate::workaroundsCached

Definition at line 434 of file qgl_p.h.

---

The documentation for this class was generated from the following files:

• /src/opengl/qgl_p.h
• /src/opengl/qgl.cpp
• /src/opengl/qgl_egl.cpp
• /src/opengl/qgl_mac.mm
• /src/opengl/qgl_win.cpp
• /src/opengl/qgl_x11.cpp
• /src/opengl/qgl_x11egl.cpp