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

equal deleted inserted replaced

-:93b982ccede2
+:5daf16870df6
 #include "QtCore/qatomic.h"
 #include "private/qwidget_p.h"
 #include "qcache.h"
 #include "qglpaintdevice_p.h"
-#ifndef QT_OPENGL_ES_1_CL
+#ifndef QT_NO_EGL
-#define q_vertexType float
+#include <QtGui/private/qegl_p.h>
-#define q_vertexTypeEnum GL_FLOAT
-#define f2vt(f)     (f)
-#define vt2f(x)     (x)
-#define i2vt(i)     (float(i))
-#else
-#define FLOAT2X(f)      (int( (f) * (65536)))
-#define X2FLOAT(x)      (float(x) / 65536.0f)
-#define f2vt(f)     FLOAT2X(f)
-#define i2vt(i)     ((i)*65536)
-#define vt2f(x)     X2FLOAT(x)
-#define q_vertexType GLfixed
-#define q_vertexTypeEnum GL_FIXED
-#endif //QT_OPENGL_ES_1_CL
-#if defined(QT_OPENGL_ES) || defined(QT_OPENGL_ES_2)
-QT_BEGIN_INCLUDE_NAMESPACE
-#if defined(QT_OPENGL_ES_2)
-#   include <GLES2/gl2.h>
-#endif
-#if defined(QT_GLES_EGL)
-#   include <GLES/egl.h>
-#else
-#   include <EGL/egl.h>
-#endif
-QT_END_INCLUDE_NAMESPACE
 #endif
 QT_BEGIN_NAMESPACE
 class QGLContext;
 #ifdef Q_WS_QWS
 class QWSGLWindowSurface;
 #endif
-#if defined(QT_OPENGL_ES)
+#ifndef QT_NO_EGL
 class QEglContext;
 #endif
 QT_BEGIN_INCLUDE_NAMESPACE
 #include <QtOpenGL/private/qglextensions_p.h>
 {
 public:
 QGLFormatPrivate()
 : ref(1)
 {
-opts = QGL::DoubleBuffer | QGL::DepthBuffer | QGL::Rgba | QGL::DirectRendering | QGL::StencilBuffer;
+opts = QGL::DoubleBuffer | QGL::DepthBuffer | QGL::Rgba | QGL::DirectRendering
+| QGL::StencilBuffer | QGL::DeprecatedFunctions;
 pln = 0;
 depthSize = accumSize = stencilSize = redSize = greenSize = blueSize = alphaSize = -1;
 numSamples = -1;
 swapInterval = -1;
+majorVersion = 1;
+minorVersion = 0;
+profile = QGLFormat::NoProfile;
 }
 QGLFormatPrivate(const QGLFormatPrivate *other)
 : ref(1),
 opts(other->opts),
 pln(other->pln),
 redSize(other->redSize),
 greenSize(other->greenSize),
 blueSize(other->blueSize),
 alphaSize(other->alphaSize),
 numSamples(other->numSamples),
-swapInterval(other->swapInterval)
+swapInterval(other->swapInterval),
+majorVersion(other->majorVersion),
+minorVersion(other->minorVersion),
+profile(other->profile)
 {
 }
 QAtomicInt ref;
 QGL::FormatOptions opts;
 int pln;
 int greenSize;
 int blueSize;
 int alphaSize;
 int numSamples;
 int swapInterval;
+int majorVersion;
+int minorVersion;
+QGLFormat::OpenGLContextProfile profile;
 };
 class QGLWidgetPrivate : public QWidgetPrivate
 {
 Q_DECLARE_PUBLIC(QGLWidget)
 QGLWidgetPrivate() : QWidgetPrivate()
 , disable_clear_on_painter_begin(false)
 #ifdef Q_WS_QWS
 , wsurf(0)
 #endif
-#if defined(Q_WS_X11) && defined(QT_OPENGL_ES)
+#if defined(Q_WS_X11) && !defined(QT_NO_EGL)
 , eglSurfaceWindowId(0)
 #endif
 {
 isGLWidget = 1;
 }
 #if defined(Q_WS_WIN)
 void updateColormap();
 QGLContext *olcx;
 #elif defined(Q_WS_X11)
 QGLOverlayWidget *olw;
-#if defined(QT_OPENGL_ES)
+#ifndef QT_NO_EGL
-void recreateEglSurface(bool force);
+void recreateEglSurface();
 WId eglSurfaceWindowId;
 #endif
 #elif defined(Q_WS_MAC)
 QGLContext *olcx;
 void updatePaintDevice();
 FragmentShader          = 0x00040000
 };
 Q_DECLARE_FLAGS(Extensions, Extension)
 static Extensions glExtensions();
-private:
 static Extensions currentContextExtensions();
 };
 /*
 QGLTemporaryContext - the main objective of this class is to have a way of
 void setVertexAttribArrayEnabled(int arrayIndex, bool enabled = true);
 void syncGlState(); // Makes sure the GL context's state is what we think it is
 #if defined(Q_WS_WIN)
+void updateFormatVersion();
+#endif
+#if defined(Q_WS_WIN)
 HGLRC rc;
 HDC dc;
 WId        win;
 int pixelFormatId;
 QGLCmap* cmap;
 HBITMAP hbitmap;
 HDC hbitmap_hdc;
 #endif
-#if defined(QT_OPENGL_ES)
+#ifndef QT_NO_EGL
+uint ownsEglContext : 1;
 QEglContext *eglContext;
 EGLSurface eglSurface;
 void destroyEglSurfaceForDevice();
+EGLSurface eglSurfaceForDevice() const;
 #elif defined(Q_WS_X11) || defined(Q_WS_MAC)
 void* cx;
 #endif
 #if defined(Q_WS_X11) || defined(Q_WS_MAC)
 void* vi;
 #if defined(Q_WS_X11)
 void* pbuf;
 quint32 gpm;
 int screen;
 QHash<QPixmapData*, QPixmap> boundPixmaps;
-QGLTexture *bindTextureFromNativePixmap(QPixmapData*, const qint64 key,
+QGLTexture *bindTextureFromNativePixmap(QPixmap*, const qint64 key,
 QGLContext::BindOptions options);
 static void destroyGlSurfaceForPixmap(QPixmapData*);
 static void unbindPixmapFromTexture(QPixmapData*);
 #endif
 #if defined(Q_WS_MAC)
 uint initDone : 1;
 uint crWin : 1;
 uint internal_context : 1;
 uint version_flags_cached : 1;
 uint extension_flags_cached : 1;
+// workarounds for driver/hw bugs on different platforms
+uint workaround_needsFullClearOnEveryFrame : 1;
+uint workaround_brokenFBOReadBack : 1;
+uint workaroundsCached : 1;
 QPaintDevice *paintDevice;
 QColor transpColor;
 QGLContext *q_ptr;
 QGLFormat::OpenGLVersionFlags version_flags;
 QGLExtensions::Extensions extension_flags;
 public:
 QGLTextureCache();
 ~QGLTextureCache();
 void insert(QGLContext *ctx, qint64 key, QGLTexture *texture, int cost);
-void remove(quint64 key) { m_cache.remove(key); }
+inline void remove(quint64 key);
+inline int size();
+inline void setMaxCost(int newMax);
+inline int maxCost();
+inline QGLTexture* getTexture(quint64 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 cleanupTexturesForCacheKey(qint64 cacheKey);
 static void cleanupTexturesForPixampData(QPixmapData* pixmap);
 static void cleanupBeforePixmapDestruction(QPixmapData* pixmap);
 private:
 QCache<qint64, QGLTexture> m_cache;
-};
+QReadWriteLock m_lock;
+};
+int QGLTextureCache::size() {
+QReadLocker locker(&m_lock);
+return m_cache.size();
+}
+void QGLTextureCache::setMaxCost(int newMax)
+{
+QWriteLocker locker(&m_lock);
+m_cache.setMaxCost(newMax);
+}
+int QGLTextureCache::maxCost()
+{
+QReadLocker locker(&m_lock);
+return m_cache.maxCost();
+}
+QGLTexture* QGLTextureCache::getTexture(quint64 key)
+{
+QReadLocker locker(&m_lock);
+return m_cache.object(key);
+}
+void QGLTextureCache::remove(quint64 key)
+{
+QWriteLocker locker(&m_lock);
+m_cache.remove(key);
+}
 extern Q_OPENGL_EXPORT QPaintEngine* qt_qgl_paint_engine();
 bool qt_gl_preferGL2Engine();

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