FCL/sf/mw/qt: comparison src/opengl/qgl.cpp

equal deleted inserted replaced

-:41300fa6a67c
+:2f34d5167611
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtOpenGL module of the Qt Toolkit.
 **
 #if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS)
 QGLExtensionFuncs QGLContextPrivate::qt_extensionFuncs;
 #endif
+#ifdef Q_WS_X11
+extern const QX11Info *qt_x11Info(const QPaintDevice *pd);
+#endif
 struct QGLThreadContext {
 QGLContext *context;
 };
 static QThreadStorage<QGLThreadContext *> qgl_context_storage;
 setOption(QGL::DirectRendering);
 setPlane(1);
 }
 };
 Q_GLOBAL_STATIC(QGLDefaultOverlayFormat, defaultOverlayFormatInstance)
-QGLExtensions::Extensions QGLExtensions::glExtensions = 0;
-bool QGLExtensions::nvidiaFboNeedsFinish = false;
 Q_GLOBAL_STATIC(QGLSignalProxy, theSignalProxy)
 QGLSignalProxy *QGLSignalProxy::instance()
 {
 return theSignalProxy();
 // values from functions in GLSL. Since working around this in
 // the GL2 engine would require a big, ugly rewrite, we're
 // falling back to the GL 1 engine..
 static bool mac_x1600_check_done = false;
 if (!mac_x1600_check_done) {
-QGLWidget *tmp = 0;
+QGLTemporaryContext *tmp = 0;
-if (!QGLContext::currentContext()) {
+if (!QGLContext::currentContext())
-tmp = new QGLWidget();
+tmp = new QGLTemporaryContext();
-tmp->makeCurrent();
-}
 if (strstr((char *) glGetString(GL_RENDERER), "X1600"))
 engineType = QPaintEngine::OpenGL;
 if (tmp)
 delete tmp;
 mac_x1600_check_done = true;
 // Also check for the FragmentShader extension in conjunction with
 // the 2.0 version flag, to cover the case where we export the display
 // from an old GL 1.1 server to a GL 2.x client. In that case we can't
 // use GL 2.0.
 if ((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_2_0)
-&& (QGLExtensions::glExtensions & QGLExtensions::FragmentShader)
+&& (QGLExtensions::glExtensions() & QGLExtensions::FragmentShader)
 && qgetenv("QT_GL_USE_OPENGL1ENGINE").isEmpty())
 engineType = QPaintEngine::OpenGL2;
 else
 engineType = QPaintEngine::OpenGL;
 #endif
 QGLFormat::OpenGLVersionFlags QGLFormat::openGLVersionFlags()
 {
 static bool cachedDefault = false;
 static OpenGLVersionFlags defaultVersionFlags = OpenGL_Version_None;
 QGLContext *currentCtx = const_cast<QGLContext *>(QGLContext::currentContext());
-QGLWidget *dummy = 0;
+QGLTemporaryContext *tmpContext = 0;
 if (currentCtx && currentCtx->d_func()->version_flags_cached)
 return currentCtx->d_func()->version_flags;
 if (!currentCtx) {
 if (cachedDefault) {
 return defaultVersionFlags;
 } else {
 if (!hasOpenGL())
 return defaultVersionFlags;
-dummy = new QGLWidget;
+tmpContext = new QGLTemporaryContext;
-dummy->makeCurrent(); // glGetString() needs a current context
 cachedDefault = true;
 }
 }
 QString versionString(QLatin1String(reinterpret_cast<const char*>(glGetString(GL_VERSION))));
 OpenGLVersionFlags versionFlags = qOpenGLVersionFlagsFromString(versionString);
 if (currentCtx) {
 currentCtx->d_func()->version_flags_cached = true;
 currentCtx->d_func()->version_flags = versionFlags;
 }
-if (dummy) {
+if (tmpContext) {
 defaultVersionFlags = versionFlags;
-delete dummy;
+delete tmpContext;
 }
 return versionFlags;
 }
 guard->m_prev->m_next = guard->m_next;
 else
 m_guards = guard->m_next;
 }
+const QGLContext *qt_gl_transfer_context(const QGLContext *ctx)
+{
+if (!ctx)
+return 0;
+QList<const QGLContext *> shares
+(QGLContextPrivate::contextGroup(ctx)->shares());
+if (shares.size() >= 2)
+return (ctx == shares.at(0)) ? shares.at(1) : shares.at(0);
+else
+return 0;
+}
 QGLContextPrivate::~QGLContextPrivate()
 {
 if (!group->m_refs.deref()) {
 Q_ASSERT(group->context() == q_ptr);
 delete group;
 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;
+for (int i = 0; i < QT_GL_VERTEX_ARRAY_TRACKED_COUNT; ++i)
+vertexAttributeArraysEnabledState[i] = false;
 }
 QGLContext* QGLContext::currentCtx = 0;
 /*
 return img;
 }
 QImage qt_gl_read_texture(const QSize &size, bool alpha_format, bool include_alpha)
 {
-QImage img(size, alpha_format ? QImage::Format_ARGB32 : QImage::Format_RGB32);
+QImage img(size, alpha_format ? QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32);
 int w = size.width();
 int h = size.height();
 #if !defined(QT_OPENGL_ES_2) && !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
 //### glGetTexImage not in GL ES 2.0, need to do something else here!
 glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, img.bits());
 : m_cache(64*1024) // cache ~64 MB worth of textures - this is not accurate though
 {
 Q_ASSERT(qt_gl_texture_cache == 0);
 qt_gl_texture_cache = this;
-QImagePixmapCleanupHooks::instance()->addPixmapModificationHook(cleanupTextures);
+QImagePixmapCleanupHooks::instance()->addPixmapDataModificationHook(cleanupTexturesForPixampData);
-#ifdef Q_WS_X11
+QImagePixmapCleanupHooks::instance()->addPixmapDataDestructionHook(cleanupBeforePixmapDestruction);
-QImagePixmapCleanupHooks::instance()->addPixmapDestructionHook(cleanupPixmapSurfaces);
+QImagePixmapCleanupHooks::instance()->addImageHook(cleanupTexturesForCacheKey);
-#endif
-QImagePixmapCleanupHooks::instance()->addImageHook(imageCleanupHook);
 }
 QGLTextureCache::~QGLTextureCache()
 {
 qt_gl_texture_cache = 0;
-QImagePixmapCleanupHooks::instance()->removePixmapModificationHook(cleanupTextures);
+QImagePixmapCleanupHooks::instance()->removePixmapDataModificationHook(cleanupTexturesForPixampData);
-#ifdef Q_WS_X11
+QImagePixmapCleanupHooks::instance()->removePixmapDataDestructionHook(cleanupBeforePixmapDestruction);
-QImagePixmapCleanupHooks::instance()->removePixmapDestructionHook(cleanupPixmapSurfaces);
+QImagePixmapCleanupHooks::instance()->removeImageHook(cleanupTexturesForCacheKey);
-#endif
-QImagePixmapCleanupHooks::instance()->removeImageHook(imageCleanupHook);
 }
 void QGLTextureCache::insert(QGLContext* ctx, qint64 key, QGLTexture* texture, int cost)
 {
 if (m_cache.totalCost() + cost > m_cache.maxCost()) {
 /*
 a hook that removes textures from the cache when a pixmap/image
 is deref'ed
 */
-void QGLTextureCache::imageCleanupHook(qint64 cacheKey)
+void QGLTextureCache::cleanupTexturesForCacheKey(qint64 cacheKey)
-{
-// ### remove when the GL texture cache becomes thread-safe
-if (qApp->thread() != QThread::currentThread())
-return;
-QGLTexture *texture = instance()->getTexture(cacheKey);
-if (texture && texture->options & QGLContext::MemoryManagedBindOption)
-instance()->remove(cacheKey);
-}
-void QGLTextureCache::cleanupTextures(QPixmap* pixmap)
 {
 // ### remove when the GL texture cache becomes thread-safe
 if (qApp->thread() == QThread::currentThread()) {
-const qint64 cacheKey = pixmap->cacheKey();
+instance()->remove(cacheKey);
-QGLTexture *texture = instance()->getTexture(cacheKey);
+Q_ASSERT(instance()->getTexture(cacheKey) == 0);
-if (texture && texture->options & QGLContext::MemoryManagedBindOption)
+}
-instance()->remove(cacheKey);
+}
-}
-}
+void QGLTextureCache::cleanupTexturesForPixampData(QPixmapData* pmd)
+{
+cleanupTexturesForCacheKey(pmd->cacheKey());
+}
+void QGLTextureCache::cleanupBeforePixmapDestruction(QPixmapData* pmd)
+{
+// Remove any bound textures first:
+cleanupTexturesForPixampData(pmd);
 #if defined(Q_WS_X11)
-void QGLTextureCache::cleanupPixmapSurfaces(QPixmap* pixmap)
+if (pmd->classId() == QPixmapData::X11Class) {
-{
+Q_ASSERT(pmd->ref == 0); // Make sure reference counting isn't broken
-// Remove any bound textures first:
+QGLContextPrivate::destroyGlSurfaceForPixmap(pmd);
-cleanupTextures(pixmap);
+}
+#endif
-QPixmapData *pd = pixmap->data_ptr().data();
+}
-if (pd->classId() == QPixmapData::X11Class) {
-Q_ASSERT(pd->ref == 1); // Make sure reference counting isn't broken
-QGLContextPrivate::destroyGlSurfaceForPixmap(pd);
-}
-}
-#endif
 void QGLTextureCache::deleteIfEmpty()
 {
 if (instance()->size() == 0)
 delete instance();
 #ifndef GL_GENERATE_MIPMAP_SGIS
 #define GL_GENERATE_MIPMAP_SGIS       0x8191
 #define GL_GENERATE_MIPMAP_HINT_SGIS  0x8192
 #endif
-Q_GLOBAL_STATIC(QGLShareRegister, _qgl_share_reg)
-Q_OPENGL_EXPORT QGLShareRegister* qgl_share_reg()
-{
-return _qgl_share_reg();
-}
 /*!
 \class QGLContext
 \brief The QGLContext class encapsulates an OpenGL rendering context.
 \ingroup painting-3D
 }
 void QGLContextPrivate::cleanup()
 {
 }
+#define ctx q_ptr
+void QGLContextPrivate::setVertexAttribArrayEnabled(int arrayIndex, bool enabled)
+{
+Q_ASSERT(arrayIndex < QT_GL_VERTEX_ARRAY_TRACKED_COUNT);
+Q_ASSERT(glEnableVertexAttribArray);
+if (vertexAttributeArraysEnabledState[arrayIndex] && !enabled)
+glDisableVertexAttribArray(arrayIndex);
+if (!vertexAttributeArraysEnabledState[arrayIndex] && enabled)
+glEnableVertexAttribArray(arrayIndex);
+vertexAttributeArraysEnabledState[arrayIndex] = enabled;
+}
+void QGLContextPrivate::syncGlState()
+{
+Q_ASSERT(glEnableVertexAttribArray);
+for (int i = 0; i < QT_GL_VERTEX_ARRAY_TRACKED_COUNT; ++i) {
+if (vertexAttributeArraysEnabledState[i])
+glEnableVertexAttribArray(i);
+else
+glDisableVertexAttribArray(i);
+}
+}
+#undef ctx
 /*!
 \overload
 Reads the compressed texture file \a fileName and generates a 2D GL
 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);
-if (texture->id > 0)
+// Enable the cleanup hooks for this image so that the texture cache entry is removed when the
-QImagePixmapCleanupHooks::enableCleanupHooks(image);
+// image gets deleted:
+QImagePixmapCleanupHooks::enableCleanupHooks(image);
 return texture;
 }
 // #define QGL_BIND_TEXTURE_DEBUG
 // 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)
+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
 #if defined(QT_OPENGL_ES_2)
 bool genMipmap = false;
 #endif
 if (glFormat.directRendering()
-&& (QGLExtensions::glExtensions & QGLExtensions::GenerateMipmap)
+&& (QGLExtensions::glExtensions() & QGLExtensions::GenerateMipmap)
 && target == GL_TEXTURE_2D
 && (options & QGLContext::MipmapBindOption))
 {
 #ifdef QGL_BIND_TEXTURE_DEBUG
 printf(" - generating mipmaps (%d ms)\n", time.elapsed());
 QImage::Format target_format = img.format();
 bool premul = options & QGLContext::PremultipliedAlphaBindOption;
 GLenum externalFormat;
 GLuint pixel_type;
-if (QGLExtensions::glExtensions & QGLExtensions::BGRATextureFormat) {
+if (QGLExtensions::glExtensions() & QGLExtensions::BGRATextureFormat) {
 externalFormat = GL_BGRA;
-pixel_type = GL_UNSIGNED_INT_8_8_8_8_REV;
+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;
 }
 // the format to GL_RGB
 Q_ASSERT(img.depth() == 32);
 qgl_byteSwapImage(img, pixel_type);
 }
 #ifdef QT_OPENGL_ES
-// OpenGL/ES requires that the internal and external formats be identical.
+// OpenGL/ES requires that the internal and external formats be
-// This is typically used to convert GL_RGBA into GL_BGRA.
+// identical.
-// Also, we need to use GL_UNSIGNED_BYTE when the format is GL_BGRA.
 internalFormat = externalFormat;
-if (pixel_type == GL_UNSIGNED_INT_8_8_8_8_REV)
-pixel_type = GL_UNSIGNED_BYTE;
 #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
 // 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);
 return texture;
 }
 QGLTexture *QGLContextPrivate::textureCacheLookup(const qint64 key, GLenum target)
 {
 return texture;
 }
 #if defined(Q_WS_X11)
 // Try to use texture_from_pixmap
-if (pd->classId() == QPixmapData::X11Class && pd->pixelType() == QPixmapData::PixmapType) {
+const QX11Info *xinfo = qt_x11Info(paintDevice);
+if (pd->classId() == QPixmapData::X11Class && pd->pixelType() == QPixmapData::PixmapType
+&& xinfo && xinfo->screen() == pixmap.x11Info().screen())
+{
 texture = bindTextureFromNativePixmap(pd, key, options);
 if (texture) {
 texture->options |= QGLContext::MemoryManagedBindOption;
 texture->boundPixmap = pd;
 boundPixmaps.insert(pd, QPixmap(pixmap));
 {
 if (image.isNull())
 return 0;
 Q_D(QGLContext);
-QGLTexture *texture = d->bindTexture(image, target, format, false, DefaultBindOption);
+QGLTexture *texture = d->bindTexture(image, target, format, DefaultBindOption);
 return texture->id;
 }
 /*!
 \since 4.6
 QGLDDSCache *dds_cache = &(d->group->m_dds_cache);
 QList<QString> ddsKeys = dds_cache->keys();
 for (int i = 0; i < ddsKeys.size(); ++i) {
 GLuint texture = dds_cache->value(ddsKeys.at(i));
 if (id == texture) {
-glDeleteTextures(1, &texture);
 dds_cache->remove(ddsKeys.at(i));
-return;
+break;
 }
 }
+// Finally, actually delete the texture ID
+glDeleteTextures(1, &id);
 }
 #ifdef Q_MAC_COMPAT_GL_FUNCTIONS
 /*! \internal */
 void QGLContext::deleteTexture(QMacCompatGLuint id)
 if (d->valid && d->paintDevice->devType() == QInternal::Widget) {
 QWidgetPrivate *wd = qt_widget_private(static_cast<QWidget *>(d->paintDevice));
 wd->usesDoubleBufferedGLContext = d->glFormat.doubleBuffer();
 }
 if (d->sharing)  // ok, we managed to share
-qgl_share_reg()->addShare(this, shareContext);
+QGLContextGroup::addShare(this, shareContext);
 return d->valid;
 }
 bool QGLContext::isValid() const
 {
 \note This function is not supported on OpenGL/ES systems.
 \note This function temporarily disables depth-testing when the
 text is drawn.
+\note This function can only be used inside a
+QPainter::beginNativePainting()/QPainter::endNativePainting() block
+if the default OpenGL paint engine is QPaintEngine::OpenGL. To make
+QPaintEngine::OpenGL the default GL engine, call
+QGL::setPreferredPaintEngine(QPaintEngine::OpenGL) before the
+QApplication constructor.
 \l{Overpainting Example}{Overpaint} with QPainter::drawText() instead.
 */
 void QGLWidget::renderText(int x, int y, const QString &str, const QFont &font, int)
 {
 glGetIntegerv(GL_VIEWPORT, &view[0]);
 int width = d->glcx->device()->width();
 int height = d->glcx->device()->height();
 bool auto_swap = autoBufferSwap();
+QPaintEngine::Type oldEngineType = qgl_engine_selector()->preferredPaintEngine();
 QPaintEngine *engine = paintEngine();
-if (engine->type() == QPaintEngine::OpenGL2)
+if (engine && (oldEngineType == QPaintEngine::OpenGL2) && engine->isActive()) {
-static_cast<QGL2PaintEngineEx *>(engine)->setRenderTextActive(true);
+qWarning("QGLWidget::renderText(): Calling renderText() while a GL 2 paint engine is"
+" active on the same device is not allowed.");
+return;
+}
+// this changes what paintEngine() returns
+qgl_engine_selector()->setPreferredPaintEngine(QPaintEngine::OpenGL);
+engine = paintEngine();
 QPainter *p;
 bool reuse_painter = false;
 if (engine->isActive()) {
 reuse_painter = true;
 p = engine->painter();
 glLoadIdentity();
 } else {
 setAutoBufferSwap(false);
 // disable glClear() as a result of QPainter::begin()
 d->disable_clear_on_painter_begin = true;
-if (engine->type() == QPaintEngine::OpenGL2) {
-qt_save_gl_state();
-glMatrixMode(GL_MODELVIEW);
-glLoadIdentity();
-}
 p = new QPainter(this);
 }
 QRect viewport(view[0], view[1], view[2], view[3]);
 if (!use_scissor_testing && viewport != rect()) {
 } else {
 p->end();
 delete p;
 setAutoBufferSwap(auto_swap);
 d->disable_clear_on_painter_begin = false;
-if (engine->type() == QPaintEngine::OpenGL2)
+}
-qt_restore_gl_state();
+qgl_engine_selector()->setPreferredPaintEngine(oldEngineType);
-}
-if (engine->type() == QPaintEngine::OpenGL2)
-static_cast<QGL2PaintEngineEx *>(engine)->setRenderTextActive(false);
 #else // QT_OPENGL_ES
 Q_UNUSED(x);
 Q_UNUSED(y);
 Q_UNUSED(str);
 Q_UNUSED(font);
 GLdouble win_x = 0, win_y = 0, win_z = 0;
 qgluProject(x, y, z, &model[0][0], &proj[0][0], &view[0],
 &win_x, &win_y, &win_z);
 win_y = height - win_y; // y is inverted
+QPaintEngine::Type oldEngineType = qgl_engine_selector()->preferredPaintEngine();
 QPaintEngine *engine = paintEngine();
-if (engine->type() == QPaintEngine::OpenGL2)
-static_cast<QGL2PaintEngineEx *>(engine)->setRenderTextActive(true);
+if (engine && (oldEngineType == QPaintEngine::OpenGL2) && engine->isActive()) {
+qWarning("QGLWidget::renderText(): Calling renderText() while a GL 2 paint engine is"
+" active on the same device is not allowed.");
+return;
+}
+// this changes what paintEngine() returns
+qgl_engine_selector()->setPreferredPaintEngine(QPaintEngine::OpenGL);
+engine = paintEngine();
 QPainter *p;
 bool reuse_painter = false;
 bool use_depth_testing = glIsEnabled(GL_DEPTH_TEST);
 bool use_scissor_testing = glIsEnabled(GL_SCISSOR_TEST);
 qt_save_gl_state();
 } else {
 setAutoBufferSwap(false);
 // disable glClear() as a result of QPainter::begin()
 d->disable_clear_on_painter_begin = true;
-if (engine->type() == QPaintEngine::OpenGL2)
-qt_save_gl_state();
 p = new QPainter(this);
 }
 QRect viewport(view[0], view[1], view[2], view[3]);
 if (!use_scissor_testing && viewport != rect()) {
 if (reuse_painter) {
 qt_restore_gl_state();
 } else {
 p->end();
 delete p;
-if (engine->type() == QPaintEngine::OpenGL2)
-qt_restore_gl_state();
 setAutoBufferSwap(auto_swap);
 d->disable_clear_on_painter_begin = false;
 }
-if (engine->type() == QPaintEngine::OpenGL2)
+qgl_engine_selector()->setPreferredPaintEngine(oldEngineType);
-static_cast<QGL2PaintEngineEx *>(engine)->setRenderTextActive(false);
 #else // QT_OPENGL_ES
 Q_UNUSED(x);
 Q_UNUSED(y);
 Q_UNUSED(z);
 Q_UNUSED(str);
 d->init(context, shareWidget);
 }
 #endif // QT3_SUPPORT
-void QGLExtensions::init_extensions()
+/*
+Returns the GL extensions for the current context.
+*/
+QGLExtensions::Extensions QGLExtensions::currentContextExtensions()
 {
 QGLExtensionMatcher extensions(reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS)));
+Extensions glExtensions;
 if (extensions.match("GL_ARB_texture_rectangle"))
 glExtensions |= TextureRectangle;
 if (extensions.match("GL_ARB_multisample"))
 glExtensions |= SampleBuffers;
 if (extensions.match("GL_ARB_texture_non_power_of_two"))
 glExtensions |= NPOTTextures;
 if (extensions.match("GL_EXT_bgra"))
 glExtensions |= BGRATextureFormat;
+return glExtensions;
+}
+/*
+Returns the GL extensions for the current QGLContext. If there is no
+current QGLContext, a default context will be created and the extensions
+for that context will be returned instead.
+*/
+QGLExtensions::Extensions QGLExtensions::glExtensions()
+{
+QGLTemporaryContext *tmpContext = 0;
+static bool cachedDefault = false;
+static Extensions defaultExtensions = 0;
+QGLContext *currentCtx = const_cast<QGLContext *>(QGLContext::currentContext());
+if (currentCtx && currentCtx->d_func()->extension_flags_cached)
+return currentCtx->d_func()->extension_flags;
+if (!currentCtx) {
+if (cachedDefault) {
+return defaultExtensions;
+} else {
+tmpContext = new QGLTemporaryContext;
+cachedDefault = true;
+}
+}
+Extensions extensionFlags = currentContextExtensions();
+if (currentCtx) {
+currentCtx->d_func()->extension_flags_cached = true;
+currentCtx->d_func()->extension_flags = extensionFlags;
+} else {
+defaultExtensions = extensionFlags;
+}
+if (tmpContext)
+delete tmpContext;
+return extensionFlags;
 }
 /*
 This is the shared initialization for all platforms. Called from QGLWidgetPrivate::init()
 */
 {
 Q_Q(QGLWidget);
 glDevice.setWidget(q);
-QGLExtensions::init();
 glcx = 0;
 autoSwap = true;
 if (context && !context->device())
 context->setDevice(q);
 q->setContext(context, shareWidget ? shareWidget->context() : 0);
 if (!glcx)
 glcx = new QGLContext(QGLFormat::defaultFormat(), q);
-q->setAttribute(Qt::WA_NoSystemBackground);
 }
 #if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS)
 Q_GLOBAL_STATIC(QString, qt_gl_lib_name)
 }
 return *qt_gl_lib_name();
 }
 #endif
-void QGLShareRegister::addShare(const QGLContext *context, const QGLContext *share) {
+void QGLContextGroup::addShare(const QGLContext *context, const QGLContext *share) {
 Q_ASSERT(context && share);
 if (context->d_ptr->group == share->d_ptr->group)
 return;
 // Make sure 'context' is not already shared with another group of contexts.
 if (group->m_shares.isEmpty())
 group->m_shares.append(share);
 group->m_shares.append(context);
 }
-QList<const QGLContext *> QGLShareRegister::shares(const QGLContext *context) {
+void QGLContextGroup::removeShare(const QGLContext *context) {
-return context->d_ptr->group->m_shares;
-}
-void QGLShareRegister::removeShare(const QGLContext *context) {
 // Remove the context from the group.
 QGLContextGroup *group = context->d_ptr->group;
 if (group->m_shares.isEmpty())
 return;
 group->m_shares.removeAll(context);
 // systems such as x86 and ARM at the moment.
 return QSize();
 }
 #if !defined(QT_OPENGL_ES)
 if (!glCompressedTexImage2D) {
-if (!(QGLExtensions::glExtensions & QGLExtensions::TextureCompression)) {
+if (!(QGLExtensions::glExtensions() & QGLExtensions::TextureCompression)) {
 qWarning("QGLContext::bindTexture(): The GL implementation does "
 "not support texture compression extensions.");
 return QSize();
 }
 glCompressedTexImage2D = (_glCompressedTexImage2DARB) ctx->getProcAddress(QLatin1String("glCompressedTexImage2DARB"));
 // We only support 2D texture loading at present.
 if (target != GL_TEXTURE_2D)
 return QSize();
 // Bail out if the necessary extension is not present.
-if (!(QGLExtensions::glExtensions & QGLExtensions::DDSTextureCompression)) {
+if (!(QGLExtensions::glExtensions() & QGLExtensions::DDSTextureCompression)) {
 qWarning("QGLContext::bindTexture(): DDS texture compression is not supported.");
 return QSize();
 }
 const DDSFormat *ddsHeader = reinterpret_cast<const DDSFormat *>(buf + 4);
 return QSize();
 }
 // Bail out if the necessary extension is not present.
 if (textureFormat == GL_ETC1_RGB8_OES) {
-if (!(QGLExtensions::glExtensions &
+if (!(QGLExtensions::glExtensions() &
 QGLExtensions::ETC1TextureCompression)) {
 qWarning("QGLContext::bindTexture(): ETC1 texture compression is not supported.");
 return QSize();
 }
 } else {
-if (!(QGLExtensions::glExtensions &
+if (!(QGLExtensions::glExtensions() &
 QGLExtensions::PVRTCTextureCompression)) {
 qWarning("QGLContext::bindTexture(): PVRTC texture compression is not supported.");
 return QSize();
 }
 }

changeset 18	2f34d5167611
parent 3	41300fa6a67c
child 19	fcece45ef507