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

equal deleted inserted replaced

-:93b982ccede2
+:5daf16870df6
 #if defined(Q_WS_X11)
 #include "private/qt_x11_p.h"
 #include "private/qpixmap_x11_p.h"
 #define INT32 dummy_INT32
 #define INT8 dummy_INT8
-#if !defined(QT_OPENGL_ES)
+#ifdef QT_NO_EGL
 # include <GL/glx.h>
 #endif
 #undef INT32
 #undef INT8
 #include "qx11info_x11.h"
 #include "qpixmap.h"
 #include "qimage.h"
 #include "qgl_p.h"
-#if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#if !defined(QT_OPENGL_ES_1)
 #include "gl2paintengineex/qpaintengineex_opengl2_p.h"
 #endif
 #ifndef QT_OPENGL_ES_2
 #include <private/qpaintengine_opengl_p.h>
 #include "qfile.h"
 #include "qlibrary.h"
 QT_BEGIN_NAMESPACE
-#ifdef QT_OPENGL_ES_1_CL
-#include "qgl_cl_p.h"
-#endif
 #if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS)
 QGLExtensionFuncs QGLContextPrivate::qt_extensionFuncs;
 #endif
 \value StencilBuffer     Enables the use of a stencil buffer.
 \value StereoBuffers     Enables the use of a stereo buffers for use with visualization hardware.
 \value DirectRendering   Specifies that the context is used for direct rendering to a display.
 \value HasOverlay        Enables the use of an overlay.
 \value SampleBuffers     Enables the use of sample buffers.
+\value DeprecatedFunctions      Enables the use of deprecated functionality for OpenGL 3.x
+contexts. A context with deprecated functionality enabled is
+called a full context in the OpenGL specification.
 \value SingleBuffer      Specifies the use of a single buffer, as opposed to double buffers.
 \value NoDepthBuffer     Disables the use of a depth buffer.
 \value ColorIndex        Specifies that the context should use a color index as its pixel format.
 \value NoAlphaChannel    Disables the use of an alpha channel.
 \value NoAccumBuffer     Disables the use of an accumulation buffer.
 \value NoStencilBuffer   Disables the use of a stencil buffer.
 \value NoStereoBuffers   Disables the use of stereo buffers.
 \value IndirectRendering Specifies that the context is used for indirect rendering to a buffer.
 \value NoOverlay         Disables the use of an overlay.
 \value NoSampleBuffers   Disables the use of sample buffers.
+\value NoDeprecatedFunctions    Disables the use of deprecated functionality for OpenGL 3.x
+contexts. A context with deprecated functionality disabled is
+called a forward compatible context in the OpenGL specification.
 \sa {Sample Buffers Example}
 */
 /*!
 if (numSamples < 0) {
 qWarning("QGLFormat::setSamples: Cannot have negative number of samples per pixel %d", numSamples);
 return;
 }
 d->numSamples = numSamples;
+setSampleBuffers(numSamples > 0);
 }
 /*!
 \since 4.2
 if (size < 0) {
 qWarning("QGLFormat::setDepthBufferSize: Cannot set negative depth buffer size %d", size);
 return;
 }
 d->depthSize = size;
+setDepth(size > 0);
 }
 /*!
 Returns the depth buffer size.
 if (size < 0) {
 qWarning("QGLFormat::setAlphaBufferSize: Cannot set negative alpha buffer size %d", size);
 return;
 }
 d->alphaSize = size;
-setOption(QGL::AlphaChannel);
+setAlpha(size > 0);
 }
 /*!
 Returns the alpha buffer size.
 if (size < 0) {
 qWarning("QGLFormat::setAccumBufferSize: Cannot set negative accumulate buffer size %d", size);
 return;
 }
 d->accumSize = size;
+setAccum(size > 0);
 }
 /*!
 Returns the accumulation buffer size.
 if (size < 0) {
 qWarning("QGLFormat::setStencilBufferSize: Cannot set negative stencil buffer size %d", size);
 return;
 }
 d->stencilSize = size;
+setStencil(size > 0);
 }
 /*!
 Returns the stencil buffer size.
 */
 int QGLFormat::stencilBufferSize() const
 {
 return d->stencilSize;
 }
+/*!
+\since 4.7
+Set the OpenGL version to the \a major and \a minor numbers. If a
+context compatible with the requested OpenGL version cannot be
+created, a context compatible with version 1.x is created instead.
+\sa majorVersion(), minorVersion()
+*/
+void QGLFormat::setVersion(int major, int minor)
+{
+if (major < 1 || minor < 0) {
+qWarning("QGLFormat::setVersion: Cannot set zero or negative version number %d.%d", major, minor);
+return;
+}
+detach();
+d->majorVersion = major;
+d->minorVersion = minor;
+}
+/*!
+\since 4.7
+Returns the OpenGL major version.
+\sa setVersion(), minorVersion()
+*/
+int QGLFormat::majorVersion() const
+{
+return d->majorVersion;
+}
+/*!
+\since 4.7
+Returns the OpenGL minor version.
+\sa setVersion(), majorVersion()
+*/
+int QGLFormat::minorVersion() const
+{
+return d->minorVersion;
+}
+/*!
+\enum QGLFormat::OpenGLContextProfile
+\since 4.7
+This enum describes the OpenGL context profiles that can be
+specified for contexts implementing OpenGL version 3.2 or
+higher. These profiles are different from OpenGL ES profiles.
+\value NoProfile            OpenGL version is lower than 3.2.
+\value CoreProfile          Functionality deprecated in OpenGL version 3.0 is not available.
+\value CompatibilityProfile Functionality from earlier OpenGL versions is available.
+*/
+/*!
+\since 4.7
+Set the OpenGL context profile to \a profile. The \a profile is
+ignored if the requested OpenGL version is less than 3.2.
+\sa profile()
+*/
+void QGLFormat::setProfile(OpenGLContextProfile profile)
+{
+detach();
+d->profile = profile;
+}
+/*!
+\since 4.7
+Returns the OpenGL context profile.
+\sa setProfile()
+*/
+QGLFormat::OpenGLContextProfile QGLFormat::profile() const
+{
+return d->profile;
+}
 /*!
 \fn bool QGLFormat::hasOpenGL()
 Returns true if the window system has any OpenGL support;
 versionFlags |= QGLFormat::OpenGL_ES_Common_Version_1_0 |
 QGLFormat::OpenGL_ES_CommonLite_Version_1_0;
 if (parts[2].startsWith(QLatin1String("1.1")))
 versionFlags |= QGLFormat::OpenGL_ES_Common_Version_1_1 |
 QGLFormat::OpenGL_ES_CommonLite_Version_1_1;
-}
+} else {
-else {
 // Not -CM, must be CL, CommonLite
 versionFlags |= QGLFormat::OpenGL_ES_CommonLite_Version_1_0;
 if (parts[2].startsWith(QLatin1String("1.1")))
 versionFlags |= QGLFormat::OpenGL_ES_CommonLite_Version_1_1;
 }
-}
+} else {
-else {
 // OpenGL ES version 2.0 or higher
 versionFlags |= QGLFormat::OpenGL_ES_Version_2_0;
 }
-}
+} else {
-else {
 // if < 3 parts to the name, it is an unrecognised OpenGL ES
 qWarning("Unrecognised OpenGL ES version");
 }
-}
+} else {
-else {
 // not ES, regular OpenGL, the version numbers are first in the string
 if (versionString.startsWith(QLatin1String("1."))) {
 switch (versionString[2].toAscii()) {
 case '5':
 versionFlags |= QGLFormat::OpenGL_Version_1_5;
 case '1':
 versionFlags |= QGLFormat::OpenGL_Version_1_1;
 default:
 break;
 }
-}
+} else if (versionString.startsWith(QLatin1String("2."))) {
-else if (versionString.startsWith(QLatin1String("2."))) {
 versionFlags |= QGLFormat::OpenGL_Version_1_1 |
 QGLFormat::OpenGL_Version_1_2 |
 QGLFormat::OpenGL_Version_1_3 |
 QGLFormat::OpenGL_Version_1_4 |
 QGLFormat::OpenGL_Version_1_5 |
 QGLFormat::OpenGL_Version_2_0;
-QString minorVersion = versionString.section(QLatin1Char(' '), 0, 0).section(QLatin1Char('.'), 1, 1);
+if (versionString[2].toAscii() == '1')
-if (minorVersion == QChar(QLatin1Char('1')))
 versionFlags |= QGLFormat::OpenGL_Version_2_1;
+} else if (versionString.startsWith(QLatin1String("3."))) {
+versionFlags |= QGLFormat::OpenGL_Version_1_1 |
+QGLFormat::OpenGL_Version_1_2 |
+QGLFormat::OpenGL_Version_1_3 |
+QGLFormat::OpenGL_Version_1_4 |
+QGLFormat::OpenGL_Version_1_5 |
+QGLFormat::OpenGL_Version_2_0 |
+QGLFormat::OpenGL_Version_2_1 |
+QGLFormat::OpenGL_Version_3_0;
+switch (versionString[2].toAscii()) {
+case '2':
+versionFlags |= QGLFormat::OpenGL_Version_3_2;
+case '1':
+versionFlags |= QGLFormat::OpenGL_Version_3_1;
+case '0':
+break;
+default:
+versionFlags |= QGLFormat::OpenGL_Version_3_1 |
+QGLFormat::OpenGL_Version_3_2;
+break;
+}
+} else {
+versionFlags |= QGLFormat::OpenGL_Version_1_1 |
+QGLFormat::OpenGL_Version_1_2 |
+QGLFormat::OpenGL_Version_1_3 |
+QGLFormat::OpenGL_Version_1_4 |
+QGLFormat::OpenGL_Version_1_5 |
+QGLFormat::OpenGL_Version_2_0 |
+QGLFormat::OpenGL_Version_2_1 |
+QGLFormat::OpenGL_Version_3_0 |
+QGLFormat::OpenGL_Version_3_1 |
+QGLFormat::OpenGL_Version_3_2;
 }
-else if (versionString.startsWith(QLatin1String("3."))) {
-versionFlags |= QGLFormat::OpenGL_Version_1_1 |
-QGLFormat::OpenGL_Version_1_2 |
-QGLFormat::OpenGL_Version_1_3 |
-QGLFormat::OpenGL_Version_1_4 |
-QGLFormat::OpenGL_Version_1_5 |
-QGLFormat::OpenGL_Version_2_0 |
-QGLFormat::OpenGL_Version_2_1 |
-QGLFormat::OpenGL_Version_3_0;
-}
-else
-qWarning("Unrecognised OpenGL version");
 }
 return versionFlags;
 }
 /*!
 Note that version 2.0 supports all the functionality of version 1.5.
 \value OpenGL_Version_2_1  OpenGL version 2.1 or higher is present.
 \value OpenGL_Version_3_0  OpenGL version 3.0 or higher is present.
+\value OpenGL_Version_3_1  OpenGL version 3.1 or higher is present.
+Note that OpenGL version 3.1 or higher does not necessarily support all the features of
+version 3.0 and lower.
+\value OpenGL_Version_3_2  OpenGL version 3.2 or higher is present.
 \value OpenGL_ES_CommonLite_Version_1_0  OpenGL ES version 1.0 Common Lite or higher is present.
 \value OpenGL_ES_Common_Version_1_0  OpenGL ES version 1.0 Common or higher is present.
 The Common profile supports all the features of Common Lite.
 \relates QGLFormat
 */
 bool operator==(const QGLFormat& a, const QGLFormat& b)
 {
-return (int) a.d->opts == (int) b.d->opts && a.d->pln == b.d->pln && a.d->alphaSize == b.d->alphaSize
+return (a.d == b.d) || ((int) a.d->opts == (int) b.d->opts
-&& a.d->accumSize == b.d->accumSize && a.d->stencilSize == b.d->stencilSize
+&& a.d->pln == b.d->pln
+&& a.d->alphaSize == b.d->alphaSize
+&& a.d->accumSize == b.d->accumSize
+&& a.d->stencilSize == b.d->stencilSize
 && a.d->depthSize == b.d->depthSize
 && a.d->redSize == b.d->redSize
 && a.d->greenSize == b.d->greenSize
 && a.d->blueSize == b.d->blueSize
 && a.d->numSamples == b.d->numSamples
-&& a.d->swapInterval == b.d->swapInterval;
+&& a.d->swapInterval == b.d->swapInterval
+&& a.d->majorVersion == b.d->majorVersion
+&& a.d->minorVersion == b.d->minorVersion
+&& a.d->profile == b.d->profile);
 }
 /*!
 Returns false if all the options of the two QGLFormat objects
 #  ifndef QT_MAC_USE_COCOA
 update = false;
 #  endif
 vi = 0;
 #endif
-#if defined(QT_OPENGL_ES)
+#ifndef QT_NO_EGL
+ownsEglContext = false;
 eglContext = 0;
 eglSurface = EGL_NO_SURFACE;
 #endif
 fbo = 0;
 crWin = false;
 extension_flags_cached = false;
 extension_flags = 0;
 current_fbo = 0;
 default_fbo = 0;
 active_engine = 0;
+workaround_needsFullClearOnEveryFrame = false;
+workaround_brokenFBOReadBack = false;
+workaroundsCached = false;
 for (int i = 0; i < QT_GL_VERTEX_ARRAY_TRACKED_COUNT; ++i)
 vertexAttributeArraysEnabledState[i] = false;
 }
 QGLContext* QGLContext::currentCtx = 0;
 // OpenGL gives ABGR (i.e. RGBA backwards); Qt wants ARGB
 for (int y = 0; y < h; y++) {
 uint *q = (uint*)img.scanLine(y);
 for (int x=0; x < w; ++x) {
 const uint pixel = *q;
-*q = ((pixel << 16) & 0xff0000) | ((pixel >> 16) & 0xff) | (pixel & 0xff00ff00);
+if (alpha_format && include_alpha) {
+*q = ((pixel << 16) & 0xff0000) | ((pixel >> 16) & 0xff)
+| (pixel & 0xff00ff00);
+} else {
+*q = 0xff000000 | ((pixel << 16) & 0xff0000)
+| ((pixel >> 16) & 0xff) | (pixel & 0x00ff00);
+}
 q++;
 }
 }
 }
 img = img.mirrored();
 }
 QImage qt_gl_read_framebuffer(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 && include_alpha) ? QImage::Format_ARGB32
+: QImage::Format_RGB32);
 int w = size.width();
 int h = size.height();
 glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, img.bits());
 convertFromGLImage(img, w, h, alpha_format, include_alpha);
 return img;
 QImage qt_gl_read_texture(const QSize &size, bool alpha_format, bool include_alpha)
 {
 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)
+#if !defined(QT_OPENGL_ES_2) && !defined(QT_OPENGL_ES_1)
 //### 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());
 #endif
 convertFromGLImage(img, w, h, alpha_format, include_alpha);
 return img;
 typedef void (*_qt_image_cleanup_hook_64)(qint64);
 extern Q_GUI_EXPORT _qt_pixmap_cleanup_hook_64 qt_pixmap_cleanup_hook_64;
 extern Q_GUI_EXPORT _qt_image_cleanup_hook_64 qt_image_cleanup_hook_64;
-static QGLTextureCache *qt_gl_texture_cache = 0;
+Q_GLOBAL_STATIC(QGLTextureCache, qt_gl_texture_cache)
 QGLTextureCache::QGLTextureCache()
 : 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()->addPixmapDataModificationHook(cleanupTexturesForPixampData);
 QImagePixmapCleanupHooks::instance()->addPixmapDataDestructionHook(cleanupBeforePixmapDestruction);
 QImagePixmapCleanupHooks::instance()->addImageHook(cleanupTexturesForCacheKey);
 }
 QGLTextureCache::~QGLTextureCache()
 {
-qt_gl_texture_cache = 0;
 QImagePixmapCleanupHooks::instance()->removePixmapDataModificationHook(cleanupTexturesForPixampData);
 QImagePixmapCleanupHooks::instance()->removePixmapDataDestructionHook(cleanupBeforePixmapDestruction);
 QImagePixmapCleanupHooks::instance()->removeImageHook(cleanupTexturesForCacheKey);
 }
 void QGLTextureCache::insert(QGLContext* ctx, qint64 key, QGLTexture* texture, int cost)
 {
+QWriteLocker locker(&m_lock);
 if (m_cache.totalCost() + cost > m_cache.maxCost()) {
 // the cache is full - make an attempt to remove something
 const QList<qint64> keys = m_cache.keys();
 int i = 0;
 while (i < m_cache.count()
 m_cache.insert(key, texture, cost);
 }
 bool QGLTextureCache::remove(QGLContext* ctx, GLuint textureId)
 {
+QWriteLocker locker(&m_lock);
 QList<qint64> keys = m_cache.keys();
 for (int i = 0; i < keys.size(); ++i) {
 QGLTexture *tex = m_cache.object(keys.at(i));
 if (tex->id == textureId && tex->context == ctx) {
 tex->options |= QGLContext::MemoryManagedBindOption; // forces a glDeleteTextures() call
 return false;
 }
 void QGLTextureCache::removeContextTextures(QGLContext* ctx)
 {
+QWriteLocker locker(&m_lock);
 QList<qint64> keys = m_cache.keys();
 for (int i = 0; i < keys.size(); ++i) {
 const qint64 &key = keys.at(i);
 if (m_cache.object(key)->context == ctx)
 m_cache.remove(key);
 }
 }
-QGLTextureCache* QGLTextureCache::instance()
-{
-if (!qt_gl_texture_cache)
-qt_gl_texture_cache = new QGLTextureCache;
-return qt_gl_texture_cache;
-}
 /*
 a hook that removes textures from the cache when a pixmap/image
 is deref'ed
 */
 void QGLTextureCache::cleanupTexturesForCacheKey(qint64 cacheKey)
 {
-// ### remove when the GL texture cache becomes thread-safe
+qt_gl_texture_cache()->remove(cacheKey);
-if (qApp->thread() == QThread::currentThread()) {
+Q_ASSERT(qt_gl_texture_cache()->getTexture(cacheKey) == 0);
-instance()->remove(cacheKey);
-Q_ASSERT(instance()->getTexture(cacheKey) == 0);
-}
 }
 void QGLTextureCache::cleanupTexturesForPixampData(QPixmapData* pmd)
 {
 QGLContextPrivate::destroyGlSurfaceForPixmap(pmd);
 }
 #endif
 }
-void QGLTextureCache::deleteIfEmpty()
+QGLTextureCache *QGLTextureCache::instance()
 {
-if (instance()->size() == 0)
+return qt_gl_texture_cache();
-delete instance();
 }
 // DDS format structure
 struct DDSFormat {
 quint32 dwSize;
 QGLContext::~QGLContext()
 {
 // remove any textures cached in this context
 QGLTextureCache::instance()->removeContextTextures(this);
-QGLTextureCache::deleteIfEmpty(); // ### thread safety
 d_ptr->group->cleanupResources(this);
 QGLSignalProxy::instance()->emitAboutToDestroyContext(this);
 reset();
 const qint64 key, QGLContext::BindOptions options)
 {
 Q_Q(QGLContext);
 #ifdef QGL_BIND_TEXTURE_DEBUG
-printf("QGLContextPrivate::bindTexture(), imageSize=(%d,%d), internalFormat =0x%x, options=%x\n",
+printf("QGLContextPrivate::bindTexture(), imageSize=(%d,%d), internalFormat =0x%x, options=%x, key=%llx\n",
-image.width(), image.height(), internalFormat, int(options));
+image.width(), image.height(), internalFormat, int(options), key);
 QTime time;
 time.start();
 #endif
 #ifndef QT_NO_DEBUG
 glGenerateMipmap(target);
 #endif
 #ifndef QT_NO_DEBUG
 GLenum error = glGetError();
 if (error != GL_NO_ERROR) {
-qWarning(" - texture upload failed, error code 0x%x\n", 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;
 /*! \internal */
 QGLTexture *QGLContextPrivate::bindTexture(const QPixmap &pixmap, GLenum target, GLint format, QGLContext::BindOptions options)
 {
 Q_Q(QGLContext);
 QPixmapData *pd = pixmap.pixmapData();
-#if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#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();
 #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())
+&& xinfo && xinfo->screen() == pixmap.x11Info().screen()
+&& target == GL_TEXTURE_2D)
 {
-texture = bindTextureFromNativePixmap(pd, key, options);
+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)
+if (!texture) {
-texture = bindTexture(pixmap.toImage(), target, format, key, options);
+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);
+}
 // NOTE: bindTexture(const QImage&, GLenum, GLint, const qint64, bool) should never return null
 Q_ASSERT(texture);
 if (texture->id > 0)
 QImagePixmapCleanupHooks::enableCleanupHooks(pixmap);
 {
 if (image.isNull())
 return 0;
 Q_D(QGLContext);
-QGLTexture *texture = d->bindTexture(image, target, format, false, options);
+QGLTexture *texture = d->bindTexture(image, target, format, options);
 return texture->id;
 }
 #ifdef Q_MAC_COMPAT_GL_FUNCTIONS
 /*! \internal */
 {
 if (image.isNull())
 return 0;
 Q_D(QGLContext);
-QGLTexture *texture = d->bindTexture(image, GLenum(target), GLint(format), false, DefaultBindOption);
+QGLTexture *texture = d->bindTexture(image, GLenum(target), GLint(format), DefaultBindOption);
 return texture->id;
 }
 /*! \internal */
 GLuint QGLContext::bindTexture(const QImage &image, QMacCompatGLenum target, QMacCompatGLint format,
 {
 if (image.isNull())
 return 0;
 Q_D(QGLContext);
-QGLTexture *texture = d->bindTexture(image, GLenum(target), GLint(format), false, options);
+QGLTexture *texture = d->bindTexture(image, GLenum(target), GLint(format), options);
 return texture->id;
 }
 #endif
 /*! \overload
 {
 return deleteTexture(GLuint(id));
 }
 #endif
-void qt_add_rect_to_array(const QRectF &r, q_vertexType *array)
+void qt_add_rect_to_array(const QRectF &r, GLfloat *array)
 {
 qreal left = r.left();
 qreal right = r.right();
 qreal top = r.top();
 qreal bottom = r.bottom();
-array[0] = f2vt(left);
+array[0] = left;
-array[1] = f2vt(top);
+array[1] = top;
-array[2] = f2vt(right);
+array[2] = right;
-array[3] = f2vt(top);
+array[3] = top;
-array[4] = f2vt(right);
+array[4] = right;
-array[5] = f2vt(bottom);
+array[5] = bottom;
-array[6] = f2vt(left);
+array[6] = left;
-array[7] = f2vt(bottom);
+array[7] = bottom;
 }
-void qt_add_texcoords_to_array(qreal x1, qreal y1, qreal x2, qreal y2, q_vertexType *array)
+void qt_add_texcoords_to_array(qreal x1, qreal y1, qreal x2, qreal y2, GLfloat *array)
 {
-array[0] = f2vt(x1);
+array[0] = x1;
-array[1] = f2vt(y1);
+array[1] = y1;
-array[2] = f2vt(x2);
+array[2] = x2;
-array[3] = f2vt(y1);
+array[3] = y1;
-array[4] = f2vt(x2);
+array[4] = x2;
-array[5] = f2vt(y2);
+array[5] = y2;
-array[6] = f2vt(x1);
+array[6] = x1;
-array[7] = f2vt(y2);
+array[7] = y2;
 }
 #if !defined(QT_OPENGL_ES_2)
 static void qDrawTextureRect(const QRectF &target, GLint textureWidth, GLint textureHeight, GLenum textureTarget)
 {
-q_vertexType tx = f2vt(1);
+GLfloat tx = 1.0f;
-q_vertexType ty = f2vt(1);
+GLfloat ty = 1.0f;
 #ifdef QT_OPENGL_ES
 Q_UNUSED(textureWidth);
 Q_UNUSED(textureHeight);
 Q_UNUSED(textureTarget);
 if (textureWidth == -1 || textureHeight == -1) {
 glGetTexLevelParameteriv(textureTarget, 0, GL_TEXTURE_WIDTH, &textureWidth);
 glGetTexLevelParameteriv(textureTarget, 0, GL_TEXTURE_HEIGHT, &textureHeight);
 }
-tx = f2vt(textureWidth);
+tx = GLfloat(textureWidth);
-ty = f2vt(textureHeight);
+ty = GLfloat(textureHeight);
 }
 #endif
-q_vertexType texCoordArray[4*2] = {
+GLfloat texCoordArray[4*2] = {
 0, ty, tx, ty, tx, 0, 0, 0
 };
-q_vertexType vertexArray[4*2];
+GLfloat vertexArray[4*2];
 qt_add_rect_to_array(target, vertexArray);
-glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+glVertexPointer(2, GL_FLOAT, 0, vertexArray);
-glTexCoordPointer(2, q_vertexTypeEnum, 0, texCoordArray);
+glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
 glEnableClientState(GL_VERTEX_ARRAY);
 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 #endif // !QT_OPENGL_ES_2
 /*!
 \since 4.4
-Draws the given texture, \a textureId, to the given target rectangle,
+This function supports the following use cases:
-\a target, in OpenGL model space. The \a textureTarget should be a 2D
-texture target.
+\list
+\i On OpenGL and OpenGL ES 1.x it draws the given texture, \a textureId,
-\note This function is not supported under OpenGL/ES 2.0.
+to the given target rectangle, \a target, in OpenGL model space. The
+\a textureTarget should be a 2D texture target.
+\i On OpenGL and OpenGL ES 2.x, if a painter is active, not inside a
+beginNativePainting / endNativePainting block, and uses the
+engine with type QPaintEngine::OpenGL2, the function will draw the given
+texture, \a textureId, to the given target rectangle, \a target,
+respecting the current painter state. This will let you draw a texture
+with the clip, transform, render hints, and composition mode set by the
+painter. Note that the texture target needs to be GL_TEXTURE_2D for this
+use case, and that this is the only supported use case under OpenGL ES 2.x.
+\endlist
 */
 void QGLContext::drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget)
 {
+#if !defined(QT_OPENGL_ES) || defined(QT_OPENGL_ES_2)
+if (d_ptr->active_engine &&
+d_ptr->active_engine->type() == QPaintEngine::OpenGL2) {
+QGL2PaintEngineEx *eng = static_cast<QGL2PaintEngineEx*>(d_ptr->active_engine);
+if (!eng->isNativePaintingActive()) {
+QRectF src(0, 0, target.width(), target.height());
+QSize size(target.width(), target.height());
+if (eng->drawTexture(target, textureId, size, src))
+return;
+}
+}
+#endif
 #ifndef QT_OPENGL_ES_2
 #ifdef QT_OPENGL_ES
 if (textureTarget != GL_TEXTURE_2D) {
 qWarning("QGLContext::drawTexture(): texture target must be GL_TEXTURE_2D on OpenGL ES");
 return;
 #endif
 #else
 Q_UNUSED(target);
 Q_UNUSED(textureId);
 Q_UNUSED(textureTarget);
-qWarning("drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget) not supported with OpenGL ES/2.0");
+qWarning("drawTexture() with OpenGL ES 2.0 requires an active OpenGL2 paint engine");
 #endif
 }
 #ifdef Q_MAC_COMPAT_GL_FUNCTIONS
 /*! \internal */
 #endif
 /*!
 \since 4.4
-Draws the given texture at the given \a point in OpenGL model
+This function supports the following use cases:
-space. The \a textureTarget should be a 2D texture target.
+\list
-\note This function is not supported under OpenGL/ES.
+\i By default it draws the given texture, \a textureId,
+at the given \a point in OpenGL model space. The
+\a textureTarget should be a 2D texture target.
+\i If a painter is active, not inside a
+beginNativePainting / endNativePainting block, and uses the
+engine with type QPaintEngine::OpenGL2, the function will draw the given
+texture, \a textureId, at the given \a point,
+respecting the current painter state. This will let you draw a texture
+with the clip, transform, render hints, and composition mode set by the
+painter. Note that the texture target needs to be GL_TEXTURE_2D for this
+use case.
+\endlist
+\note This function is not supported under any version of OpenGL ES.
 */
 void QGLContext::drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget)
 {
-// this would be ok on OpenGL ES 2.0, but currently we don't have a define for that
 #ifdef QT_OPENGL_ES
 Q_UNUSED(point);
 Q_UNUSED(textureId);
 Q_UNUSED(textureTarget);
 qWarning("drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget) not supported with OpenGL ES, use rect version instead");
 #else
 const bool wasEnabled = glIsEnabled(GL_TEXTURE_2D);
 GLint oldTexture;
 glGetIntegerv(GL_TEXTURE_BINDING_2D, &oldTexture);
 glEnable(textureTarget);
 GLint textureWidth;
 GLint textureHeight;
 glGetTexLevelParameteriv(textureTarget, 0, GL_TEXTURE_WIDTH, &textureWidth);
 glGetTexLevelParameteriv(textureTarget, 0, GL_TEXTURE_HEIGHT, &textureHeight);
+if (d_ptr->active_engine &&
+d_ptr->active_engine->type() == QPaintEngine::OpenGL2) {
+QGL2PaintEngineEx *eng = static_cast<QGL2PaintEngineEx*>(d_ptr->active_engine);
+if (!eng->isNativePaintingActive()) {
+QRectF dest(point, QSizeF(textureWidth, textureHeight));
+QRectF src(0, 0, textureWidth, textureHeight);
+QSize size(textureWidth, textureHeight);
+if (eng->drawTexture(dest, textureId, size, src))
+return;
+}
+}
 qDrawTextureRect(QRectF(point, QSizeF(textureWidth, textureHeight)), textureWidth, textureHeight, textureTarget);
 if (!wasEnabled)
 glDisable(textureTarget);
 Generates a set of 256 display lists for the 256 first characters
 in the font \a font. The first list will start at index \a listBase.
 \sa QGLWidget::renderText()
 */
 /*****************************************************************************
 QGLWidget implementation
 *****************************************************************************/
 \endlist
 Overpainting 2D content on top of 3D content takes a little more effort.
 One approach to doing this is shown in the
 \l{Overpainting Example}{Overpainting} example.
+\section1 Threading
+It is possible to render into a QGLWidget from another thread, but it
+requires that all access to the GL context is safe guarded. The Qt GUI
+thread will try to use the context in resizeEvent and paintEvent, so in
+order for threaded rendering using a GL widget to work, these functions
+need to be intercepted in the GUI thread and handled accordingly in the
+application.
 \e{OpenGL is a trademark of Silicon Graphics, Inc. in the United States and other
 countries.}
 \sa QGLPixelBuffer, {Hello GL Example}, {2D Painting Example}, {Overpainting Example},
 setContext(new QGLContext(d->glcx->requestedFormat(), this));
 // ### recreating the overlay isn't supported atm
 }
 }
-#if defined(QT_OPENGL_ES)
+#ifndef QT_NO_EGL
 // A re-parent is likely to destroy the X11 window and re-create it. It is important
 // that we free the EGL surface _before_ the winID changes - otherwise we can leak.
 if (e->type() == QEvent::ParentAboutToChange)
 d->glcx->d_func()->destroyEglSurfaceForDevice();
 if ((e->type() == QEvent::ParentChange) || (e->type() == QEvent::WindowStateChange)) {
 // The window may have been re-created during re-parent or state change - if so, the EGL
 // surface will need to be re-created.
-d->recreateEglSurface(false);
+d->recreateEglSurface();
 }
 #endif
 #elif defined(Q_WS_WIN)
 if (e->type() == QEvent::ParentChange) {
 QGLContext *newContext = new QGLContext(d->glcx->requestedFormat(), this);
 #endif
 /*!
 \since 4.4
-Draws the given texture, \a textureId to the given target rectangle,
+Calls the corresponding QGLContext::drawTexture() on
-\a target, in OpenGL model space. The \a textureTarget should be a 2D
+this widget's context.
-texture target.
-Equivalent to the corresponding QGLContext::drawTexture().
 */
 void QGLWidget::drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget)
 {
 Q_D(QGLWidget);
 d->glcx->drawTexture(target, textureId, textureTarget);
 #endif
 /*!
 \since 4.4
-Draws the given texture, \a textureId, at the given \a point in OpenGL
+Calls the corresponding QGLContext::drawTexture() on
-model space. The \a textureTarget should be a 2D texture target.
+this widget's context.
-Equivalent to the corresponding QGLContext::drawTexture().
 */
 void QGLWidget::drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget)
 {
 Q_D(QGLWidget);
 d->glcx->drawTexture(point, textureId, textureTarget);
 Q_D(QGLWidget);
 d->glcx->drawTexture(point, GLuint(textureId), GLenum(textureTarget));
 }
 #endif
-#if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#ifndef QT_OPENGL_ES_1
 Q_GLOBAL_STATIC(QGL2PaintEngineEx, qt_gl_2_engine)
 #endif
 #ifndef QT_OPENGL_ES_2
 Q_GLOBAL_STATIC(QOpenGLPaintEngine, qt_gl_engine)
 #endif
 Q_OPENGL_EXPORT QPaintEngine* qt_qgl_paint_engine()
 {
-#if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_1_CL)
+#if defined(QT_OPENGL_ES_1)
 return qt_gl_engine();
 #elif defined(QT_OPENGL_ES_2)
 return qt_gl_2_engine();
 #else
 if (qt_gl_preferGL2Engine())
 #if defined(QT_OPENGL_ES_2)
 glExtensions |= FramebufferObject;
 glExtensions |= GenerateMipmap;
 glExtensions |= FragmentShader;
 #endif
-#if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_1_CL)
+#if defined(QT_OPENGL_ES_1)
 if (extensions.match("GL_OES_framebuffer_object"))
 glExtensions |= FramebufferObject;
 #endif
 #if defined(QT_OPENGL_ES)
 if (extensions.match("GL_OES_packed_depth_stencil"))
 glExtensions |= BGRATextureFormat;
 return glExtensions;
 }
+class QGLDefaultExtensions
+{
+public:
+QGLDefaultExtensions() {
+QGLTemporaryContext tempContext;
+extensions = QGLExtensions::currentContextExtensions();
+}
+QGLExtensions::Extensions extensions;
+};
+Q_GLOBAL_STATIC(QGLDefaultExtensions, qtDefaultExtensions)
 /*
 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;
+Extensions extensionFlags = 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) {
+extensionFlags = qtDefaultExtensions()->extensions;
-return defaultExtensions;
+} else {
-} else {
+extensionFlags = currentContextExtensions();
-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_OPENGL_EXPORT const QString qt_gl_library_name()
 {
 if (qt_gl_lib_name()->isNull()) {
-#if defined(Q_WS_X11) || defined(Q_WS_QWS)
+#ifdef Q_WS_MAC
+return QLatin1String("/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib");
+#else
+# if defined(QT_OPENGL_ES_1)
+return QLatin1String("GLES_CM");
+# elif defined(QT_OPENGL_ES_2)
+return QLatin1String("GLESv2");
+# else
 return QLatin1String("GL");
-#else // Q_WS_MAC
+# endif
-return QLatin1String("/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib");
+#endif // defined Q_WS_MAC
-#endif
 }
 return *qt_gl_lib_name();
 }
 #endif

branch	GCC_SURGE
changeset 31	5daf16870df6
parent 30	5dc02b23752f
child 33	3e2da88830cd