Changeset 561 for trunk/src/opengl/qgl_p.h

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/opengl/qgl_p.h (modified) (16 diffs)

trunk/src/opengl/qgl_p.h

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtOpenGL module of the Qt Toolkit.
@@ -21 +22 @@
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -60 +60 @@
 #include "QtCore/qthreadstorage.h"
 #include "QtCore/qhash.h"
+#include "QtCore/qatomic.h"
 #include "private/qwidget_p.h"
+#include "qcache.h"
+#include "qglpaintdevice_p.h"
 
 #ifndef QT_OPENGL_ES_1_CL
@@ -127 +130 @@
 {
 public:
-    QGLFormatPrivate() {
+    QGLFormatPrivate()
+        : ref(1)
+    {
         opts = QGL::DoubleBuffer | QGL::DepthBuffer | QGL::Rgba | QGL::DirectRendering | QGL::StencilBuffer;
-#if defined(QT_OPENGL_ES_2)
-        opts |= QGL::SampleBuffers;
-#endif
         pln = 0;
         depthSize = accumSize = stencilSize = redSize = greenSize = blueSize = alphaSize = -1;
@@ -137 +139 @@
         swapInterval = -1;
     }
+    QGLFormatPrivate(const QGLFormatPrivate *other)
+        : ref(1),
+          opts(other->opts),
+          pln(other->pln),
+          depthSize(other->depthSize),
+          accumSize(other->accumSize),
+          stencilSize(other->stencilSize),
+          redSize(other->redSize),
+          greenSize(other->greenSize),
+          blueSize(other->blueSize),
+          alphaSize(other->alphaSize),
+          numSamples(other->numSamples),
+          swapInterval(other->swapInterval)
+    {
+    }
+    QAtomicInt ref;
     QGL::FormatOptions opts;
     int pln;
@@ -155 +173 @@
 public:
     QGLWidgetPrivate() : QWidgetPrivate()
+                       , disable_clear_on_painter_begin(false)
 #ifdef Q_WS_QWS
                        , wsurf(0)
@@ -171 +190 @@
 
     QGLContext *glcx;
+    QGLWidgetGLPaintDevice glDevice;
     bool autoSwap;
 
     QGLColormap cmap;
+#ifndef QT_OPENGL_ES
     QMap<QString, int> displayListCache;
+#endif
+
+    bool disable_clear_on_painter_begin;
 
 #if defined(Q_WS_WIN)
@@ -193 +217 @@
 };
 
+class QGLContextResource;
+class QGLSharedResourceGuard;
+
+typedef QHash<QString, GLuint> QGLDDSCache;
+
+// QGLContextPrivate has the responsibility of creating context groups.
+// QGLContextPrivate and QGLShareRegister will both maintain the reference counter and destroy
+// context groups when needed.
+// QGLShareRegister has the responsibility of keeping the context pointer up to date.
+class QGLContextGroup
+{
+public:
+    ~QGLContextGroup();
+
+    QGLExtensionFuncs &extensionFuncs() {return m_extensionFuncs;}
+    const QGLContext *context() const {return m_context;}
+    bool isSharing() const { return m_shares.size() >= 2; }
+
+    void addGuard(QGLSharedResourceGuard *guard);
+    void removeGuard(QGLSharedResourceGuard *guard);
+private:
+    QGLContextGroup(const QGLContext *context) : m_context(context), m_guards(0), m_refs(1) { }
+
+    QGLExtensionFuncs m_extensionFuncs;
+    const QGLContext *m_context; // context group's representative
+    QList<const QGLContext *> m_shares;
+    QHash<QGLContextResource *, void *> m_resources;
+    QGLSharedResourceGuard *m_guards; // double-linked list of active guards.
+    QAtomicInt m_refs;
+    QGLDDSCache m_dds_cache;
+
+    void cleanupResources(const QGLContext *ctx);
+
+    friend class QGLShareRegister;
+    friend class QGLContext;
+    friend class QGLContextPrivate;
+    friend class QGLContextResource;
+};
+
+class QGLTexture;
+
 class QGLContextPrivate
 {
     Q_DECLARE_PUBLIC(QGLContext)
 public:
-    explicit QGLContextPrivate(QGLContext *context) : internal_context(false), q_ptr(context) {}
-    ~QGLContextPrivate() {}
-    GLuint bindTexture(const QImage &image, GLenum target, GLint format, const qint64 key,
-                       bool clean = false);
-    GLuint bindTexture(const QPixmap &pixmap, GLenum target, GLint format, bool clean);
-    GLuint bindTexture(const QImage &image, GLenum target, GLint format, bool clean);
-    bool textureCacheLookup(const qint64 key, GLenum target, GLuint *id);
+    explicit QGLContextPrivate(QGLContext *context) : internal_context(false), q_ptr(context) {group = new QGLContextGroup(context);}
+    ~QGLContextPrivate();
+    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 *textureCacheLookup(const qint64 key, GLenum target);
     void init(QPaintDevice *dev, const QGLFormat &format);
     QImage convertToGLFormat(const QImage &image, bool force_premul, GLenum texture_format);
@@ -221 +288 @@
 #if defined(QT_OPENGL_ES)
     QEglContext *eglContext;
+    EGLSurface eglSurface;
+    void destroyEglSurfaceForDevice();
 #elif defined(Q_WS_X11) || defined(Q_WS_MAC)
     void* cx;
@@ -231 +300 @@
     quint32 gpm;
     int screen;
+    QHash<QPixmapData*, QPixmap> boundPixmaps;
+    QGLTexture *bindTextureFromNativePixmap(QPixmapData*, const qint64 key,
+                                            QGLContext::BindOptions options);
+    static void destroyGlSurfaceForPixmap(QPixmapData*);
+    static void unbindPixmapFromTexture(QPixmapData*);
 #endif
 #if defined(Q_WS_MAC)
@@ -239 +313 @@
     QGLFormat glFormat;
     QGLFormat reqFormat;
-    GLuint pbo;
+    GLuint fbo;
 
     uint valid : 1;
@@ -245 +319 @@
     uint initDone : 1;
     uint crWin : 1;
-    uint clear_on_painter_begin : 1;
     uint internal_context : 1;
     uint version_flags_cached : 1;
@@ -253 +326 @@
     QGLFormat::OpenGLVersionFlags version_flags;
 
-    QGLExtensionFuncs extensionFuncs;
+    QGLContextGroup *group;
     GLint max_texture_size;
 
+    GLuint current_fbo;
+    GLuint default_fbo;
+    QPaintEngine *active_engine;
+
+    static inline QGLContextGroup *contextGroup(const QGLContext *ctx) { return ctx->d_ptr->group; }
+
 #ifdef Q_WS_WIN
-    static inline QGLExtensionFuncs& qt_get_extension_funcs(const QGLContext *ctx) { return ctx->d_ptr->extensionFuncs; }
+    static inline QGLExtensionFuncs& extensionFuncs(const QGLContext *ctx) { return ctx->d_ptr->group->extensionFuncs(); }
 #endif
 
 #if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS)
     static QGLExtensionFuncs qt_extensionFuncs;
-    static inline QGLExtensionFuncs& qt_get_extension_funcs(const QGLContext *) { return qt_extensionFuncs; }
-#endif
-
-    QPixmapFilter *createPixmapFilter(int type) const;
+    static inline QGLExtensionFuncs& extensionFuncs(const QGLContext *) { return qt_extensionFuncs; }
+#endif
+
+    static void setCurrentContext(QGLContext *context);
 };
 
 // ### make QGLContext a QObject in 5.0 and remove the proxy stuff
-class QGLSignalProxy : public QObject
+class Q_OPENGL_EXPORT QGLSignalProxy : public QObject
 {
     Q_OBJECT
@@ -297 +376 @@
         PackedDepthStencil      = 0x00000200,
         NVFloatBuffer           = 0x00000400,
-        PixelBufferObject       = 0x00000800
+        PixelBufferObject       = 0x00000800,
+        FramebufferBlit         = 0x00001000,
+        NPOTTextures            = 0x00002000,
+        BGRATextureFormat       = 0x00004000,
+        DDSTextureCompression   = 0x00008000,
+        ETC1TextureCompression  = 0x00010000,
+        PVRTCTextureCompression = 0x00020000,
+        FragmentShader          = 0x00040000
     };
     Q_DECLARE_FLAGS(Extensions, Extension)
@@ -310 +396 @@
 
 
-struct QGLThreadContext {
+class Q_OPENGL_EXPORT QGLShareRegister
+{
+public:
+    QGLShareRegister() {}
+    ~QGLShareRegister() {}
+
+    void addShare(const QGLContext *context, const QGLContext *share);
+    QList<const QGLContext *> shares(const QGLContext *context);
+    void removeShare(const QGLContext *context);
+};
+
+extern Q_OPENGL_EXPORT QGLShareRegister* qgl_share_reg();
+
+// Temporarily make a context current if not already current or
+// shared with the current contex.  The previous context is made
+// current when the object goes out of scope.
+class Q_OPENGL_EXPORT QGLShareContextScope
+{
+public:
+    QGLShareContextScope(const QGLContext *ctx)
+        : m_oldContext(0)
+    {
+        QGLContext *currentContext = const_cast<QGLContext *>(QGLContext::currentContext());
+        if (currentContext != ctx && !QGLContext::areSharing(ctx, currentContext)) {
+            m_oldContext = currentContext;
+            m_ctx = const_cast<QGLContext *>(ctx);
+            m_ctx->makeCurrent();
+        } else {
+            m_ctx = currentContext;
+        }
+    }
+
+    operator QGLContext *()
+    {
+        return m_ctx;
+    }
+
+    QGLContext *operator->()
+    {
+        return m_ctx;
+    }
+
+    ~QGLShareContextScope()
+    {
+        if (m_oldContext)
+            m_oldContext->makeCurrent();
+    }
+
+private:
+    QGLContext *m_oldContext;
+    QGLContext *m_ctx;
+};
+
+class QGLTexture {
+public:
+    QGLTexture(QGLContext *ctx = 0, GLuint tx_id = 0, GLenum tx_target = GL_TEXTURE_2D,
+               QGLContext::BindOptions opt = QGLContext::DefaultBindOption)
+        : context(ctx),
+          id(tx_id),
+          target(tx_target),
+          options(opt)
+#if defined(Q_WS_X11)
+        , boundPixmap(0)
+#endif
+    {}
+
+    ~QGLTexture() {
+        if (options & QGLContext::MemoryManagedBindOption) {
+            Q_ASSERT(context);
+            QGLShareContextScope scope(context);
+#if defined(Q_WS_X11)
+            // Although glXReleaseTexImage is a glX call, it must be called while there
+            // is a current context - the context the pixmap was bound to a texture in.
+            // Otherwise the release doesn't do anything and you get BadDrawable errors
+            // when you come to delete the context.
+            if (boundPixmap)
+                QGLContextPrivate::unbindPixmapFromTexture(boundPixmap);
+#endif
+            glDeleteTextures(1, &id);
+        }
+     }
+
     QGLContext *context;
-};
-extern QThreadStorage<QGLThreadContext *> qgl_context_storage;
-
-typedef QMultiHash<const QGLContext *, const QGLContext *> QGLSharingHash;
-class QGLShareRegister
-{
-public:
-    QGLShareRegister() {}
-    ~QGLShareRegister() { reg.clear(); }
-
-    bool checkSharing(const QGLContext *context1, const QGLContext *context2, const QGLContext * skip=0) {
-        if (context1 == context2)
-            return true;
-        QList<const QGLContext *> shares = reg.values(context1);
-        for (int k=0; k<shares.size(); ++k) {
-            const QGLContext *ctx = shares.at(k);
-            if (ctx == skip) // avoid an indirect circular loop (infinite recursion)
-                continue;
-            if (ctx == context2)
+    GLuint id;
+    GLenum target;
+
+    QGLContext::BindOptions options;
+
+#if defined(Q_WS_X11)
+    QPixmapData* boundPixmap;
+#endif
+
+    bool canBindCompressedTexture
+        (const char *buf, int len, const char *format, bool *hasAlpha);
+    QSize bindCompressedTexture
+        (const QString& fileName, const char *format = 0);
+    QSize bindCompressedTexture
+        (const char *buf, int len, const char *format = 0);
+    QSize bindCompressedTextureDDS(const char *buf, int len);
+    QSize bindCompressedTexturePVR(const char *buf, int len);
+};
+
+class QGLTextureCache {
+public:
+    QGLTextureCache();
+    ~QGLTextureCache();
+
+    void insert(QGLContext *ctx, qint64 key, QGLTexture *texture, int cost);
+    void remove(quint64 key) { m_cache.remove(key); }
+    bool remove(QGLContext *ctx, GLuint textureId);
+    void removeContextTextures(QGLContext *ctx);
+    int size() { return m_cache.size(); }
+    void setMaxCost(int newMax) { m_cache.setMaxCost(newMax); }
+    int maxCost() {return m_cache.maxCost(); }
+    QGLTexture* getTexture(quint64 key) { return m_cache.object(key); }
+
+    static QGLTextureCache *instance();
+    static void deleteIfEmpty();
+    static void imageCleanupHook(qint64 cacheKey);
+    static void cleanupTextures(QPixmap* pixmap);
+#ifdef Q_WS_X11
+    // X11 needs to catch pixmap data destruction to delete EGL/GLX pixmap surfaces
+    static void cleanupPixmapSurfaces(QPixmap* pixmap);
+#endif
+
+private:
+    QCache<qint64, QGLTexture> m_cache;
+};
+
+
+extern Q_OPENGL_EXPORT QPaintEngine* qt_qgl_paint_engine();
+
+bool qt_gl_preferGL2Engine();
+
+inline GLenum qt_gl_preferredTextureFormat()
+{
+    return (QGLExtensions::glExtensions & QGLExtensions::BGRATextureFormat) && QSysInfo::ByteOrder == QSysInfo::LittleEndian
+        ? GL_BGRA : GL_RGBA;
+}
+
+inline GLenum qt_gl_preferredTextureTarget()
+{
+#if defined(QT_OPENGL_ES_2)
+    return GL_TEXTURE_2D;
+#else
+    return (QGLExtensions::glExtensions & QGLExtensions::TextureRectangle)
+           && !qt_gl_preferGL2Engine()
+           ? GL_TEXTURE_RECTANGLE_NV
+           : GL_TEXTURE_2D;
+#endif
+}
+
+// One resource per group of shared contexts.
+class Q_AUTOTEST_EXPORT QGLContextResource
+{
+public:
+    typedef void (*FreeFunc)(void *);
+    QGLContextResource(FreeFunc f);
+    ~QGLContextResource();
+    // Set resource 'value' for 'key' and all its shared contexts.
+    void insert(const QGLContext *key, void *value);
+    // Return resource for 'key' or a shared context.
+    void *value(const QGLContext *key);
+    // Cleanup 'value' in response to a context group being destroyed.
+    void cleanup(const QGLContext *ctx, void *value);
+private:
+    FreeFunc free;
+    QAtomicInt active;
+};
+
+// Put a guard around a GL object identifier and its context.
+// When the context goes away, a shared context will be used
+// in its place.  If there are no more shared contexts, then
+// the identifier is returned as zero - it is assumed that the
+// context destruction cleaned up the identifier in this case.
+class Q_OPENGL_EXPORT QGLSharedResourceGuard
+{
+public:
+    QGLSharedResourceGuard(const QGLContext *context)
+        : m_group(0), m_id(0), m_next(0), m_prev(0)
+    {
+        setContext(context);
+    }
+    QGLSharedResourceGuard(const QGLContext *context, GLuint id)
+        : m_group(0), m_id(id), m_next(0), m_prev(0)
+    {
+        setContext(context);
+    }
+    ~QGLSharedResourceGuard();
+
+    const QGLContext *context() const
+    {
+        return m_group ? m_group->context() : 0;
+    }
+
+    void setContext(const QGLContext *context);
+
+    GLuint id() const
+    {
+        return m_id;
+    }
+
+    void setId(GLuint id)
+    {
+        m_id = id;
+    }
+
+private:
+    QGLContextGroup *m_group;
+    GLuint m_id;
+    QGLSharedResourceGuard *m_next;
+    QGLSharedResourceGuard *m_prev;
+
+    friend class QGLContextGroup;
+};
+
+
+// This class can be used to match GL extensions with doing any mallocs. The
+// class assumes that the GL extension string ends with a space character,
+// which it should do on all conformant platforms. Create the object and pass
+// in a pointer to the extension string, then call match() on each extension
+// that should be matched. The match() function takes the extension name
+// *without* the terminating space character as input.
+
+class QGLExtensionMatcher
+{
+public:
+    QGLExtensionMatcher(const char *str)
+        : gl_extensions(str), gl_extensions_length(qstrlen(str))
+    {}
+
+    bool match(const char *str) {
+        int str_length = qstrlen(str);
+        const char *extensions = gl_extensions;
+        int extensions_length = gl_extensions_length;
+
+        while (1) {
+            // the total length that needs to be matched is the str_length +
+            // the space character that terminates the extension name
+            if (extensions_length < str_length + 1)
+                return false;
+            if (qstrncmp(extensions, str, str_length) == 0 && extensions[str_length] == ' ')
                 return true;
-            if (checkSharing(ctx, context2, context1))
-                return true;
+
+            int split_pos = 0;
+            while (split_pos < extensions_length && extensions[split_pos] != ' ')
+                ++split_pos;
+            ++split_pos; // added for the terminating space character
+            extensions += split_pos;
+            extensions_length -= split_pos;
         }
         return false;
     }
 
-    void addShare(const QGLContext *context, const QGLContext *share) {
-        reg.insert(context, share); // context sharing works both ways
-        reg.insert(share, context);
-    }
-
-    void removeShare(const QGLContext *context) {
-        QGLSharingHash::iterator it = reg.begin();
-        while (it != reg.end()) {
-            if (it.key() == context || it.value() == context)
-                it = reg.erase(it);
-            else
-                ++it;
-        }
-    }
-
-    void replaceShare(const QGLContext *oldContext, const QGLContext *newContext) {
-        QGLSharingHash::iterator it = reg.begin();
-        while (it != reg.end()) {
-            if (it.key() == oldContext)
-                reg.insert(newContext, it.value());
-            else if (it.value() == oldContext)
-                reg.insert(it.key(), newContext);
-            ++it;
-        }
-        removeShare(oldContext);
-    }
-
 private:
-    QGLSharingHash reg;
-};
-
-extern Q_OPENGL_EXPORT QGLShareRegister* qgl_share_reg();
-
-#ifdef Q_WS_QWS
-class QOpenGLPaintEngine;
-extern QOpenGLPaintEngine* qt_qgl_paint_engine();
-
-extern EGLDisplay qt_qgl_egl_display();
-#endif
-
-inline GLenum qt_gl_preferredTextureFormat()
-{
-    return QSysInfo::ByteOrder == QSysInfo::BigEndian ? GL_RGBA : GL_BGRA;
-}
-
-inline GLenum qt_gl_preferredTextureTarget()
-{
-    return (QGLExtensions::glExtensions & QGLExtensions::TextureRectangle)
-           ? GL_TEXTURE_RECTANGLE_NV
-           : GL_TEXTURE_2D;
-}
-
+    const char *gl_extensions;
+    int gl_extensions_length;
+};
 
 QT_END_NAMESPACE