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

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 public:
 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;
 numSamples = -1;
 swapInterval = -1;
 }
 };
 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) { }
 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;
 HDC hbitmap_hdc;
 #endif
 #if defined(QT_OPENGL_ES)
 QEglContext *eglContext;
 EGLSurface eglSurface;
+void destroyEglSurfaceForDevice();
 #elif defined(Q_WS_X11) || defined(Q_WS_MAC)
 void* cx;
 #endif
 #if defined(Q_WS_X11) || defined(Q_WS_MAC)
 void* vi;
 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
 StencilWrap             = 0x00000100,
 PackedDepthStencil      = 0x00000200,
 NVFloatBuffer           = 0x00000400,
 PixelBufferObject       = 0x00000800,
 FramebufferBlit         = 0x00001000,
-NPOTTextures            = 0x00002000
+NPOTTextures            = 0x00002000,
+BGRATextureFormat       = 0x00004000,
+DDSTextureCompression   = 0x00008000,
+ETC1TextureCompression  = 0x00010000,
+PVRTCTextureCompression = 0x00020000,
+FragmentShader          = 0x00040000
 };
 Q_DECLARE_FLAGS(Extensions, Extension)
 static Extensions glExtensions;
 static bool nvidiaFboNeedsFinish;
 };
 Q_DECLARE_OPERATORS_FOR_FLAGS(QGLExtensions::Extensions)
-class Q_AUTOTEST_EXPORT QGLShareRegister
+class Q_OPENGL_EXPORT QGLShareRegister
 {
 public:
 QGLShareRegister() {}
 ~QGLShareRegister() {}
 #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();
 bool qt_gl_preferGL2Engine();
 inline GLenum qt_gl_preferredTextureFormat()
 {
-return QSysInfo::ByteOrder == QSysInfo::BigEndian ? GL_RGBA : GL_BGRA;
+return (QGLExtensions::glExtensions & QGLExtensions::BGRATextureFormat) && QSysInfo::ByteOrder == QSysInfo::LittleEndian
+? GL_BGRA : GL_RGBA;
 }
 inline GLenum qt_gl_preferredTextureTarget()
 {
 #if defined(QT_OPENGL_ES_2)
 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;
+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;
+}
+private:
+const char *gl_extensions;
+int gl_extensions_length;
+};
 QT_END_NAMESPACE
 #endif // QGL_P_H

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7