summaryrefslogtreecommitdiffstats
path: root/src/opengl
diff options
context:
space:
mode:
Diffstat (limited to 'src/opengl')
-rw-r--r--src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp8
-rw-r--r--src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h6
-rw-r--r--src/opengl/qgl_egl.cpp127
-rw-r--r--src/opengl/qgl_egl_p.h6
-rw-r--r--src/opengl/qgl_p.h11
-rw-r--r--src/opengl/qgl_qws.cpp20
-rw-r--r--src/opengl/qgl_wince.cpp18
-rw-r--r--src/opengl/qgl_x11.cpp2
-rw-r--r--src/opengl/qgl_x11egl.cpp459
-rw-r--r--src/opengl/qglpixelbuffer.h1
-rw-r--r--src/opengl/qglpixelbuffer_egl.cpp10
-rw-r--r--src/opengl/qgraphicssystem_gl.cpp1
-rw-r--r--src/opengl/qpixmapdata_x11gl_egl.cpp167
-rw-r--r--src/opengl/qpixmapdata_x11gl_p.h9
-rw-r--r--src/opengl/qwindowsurface_gl.cpp14
15 files changed, 282 insertions, 577 deletions
diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
index 25ad5d7..2b5f2f4 100644
--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
+++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
@@ -1641,7 +1641,8 @@ void QGL2PaintEngineExPrivate::drawCachedGlyphs(QFontEngineGlyphCache::Type glyp
s->matrix = old;
}
-void QGL2PaintEngineEx::drawPixmapFragments(const QPainter::Fragment *fragments, int fragmentCount, const QPixmap &pixmap, QPainter::FragmentHints hints)
+void QGL2PaintEngineEx::drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap,
+ QPainter::PixmapFragmentHints hints)
{
Q_D(QGL2PaintEngineEx);
// Use fallback for extended composition modes.
@@ -1655,9 +1656,9 @@ void QGL2PaintEngineEx::drawPixmapFragments(const QPainter::Fragment *fragments,
}
-void QGL2PaintEngineExPrivate::drawPixmapFragments(const QPainter::Fragment *fragments,
+void QGL2PaintEngineExPrivate::drawPixmapFragments(const QPainter::PixmapFragment *fragments,
int fragmentCount, const QPixmap &pixmap,
- QPainter::FragmentHints hints)
+ QPainter::PixmapFragmentHints hints)
{
GLfloat dx = 1.0f / pixmap.size().width();
GLfloat dy = 1.0f / pixmap.size().height();
@@ -1867,6 +1868,7 @@ bool QGL2PaintEngineEx::end()
delete d->shaderManager;
d->shaderManager = 0;
+ d->currentBrush = QBrush();
#ifdef QT_OPENGL_CACHE_AS_VBOS
if (!d->unusedVBOSToClean.isEmpty()) {
diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
index 5d3608b..ed8fbbc 100644
--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
+++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
@@ -125,7 +125,8 @@ public:
virtual void drawTexture(const QRectF &r, GLuint textureId, const QSize &size, const QRectF &sr);
virtual void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
- virtual void drawPixmapFragments(const QPainter::Fragment *fragments, int fragmentCount, const QPixmap &pixmap, QPainter::FragmentHints hints);
+ virtual void drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap,
+ QPainter::PixmapFragmentHints hints);
virtual void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,
Qt::ImageConversionFlags flags = Qt::AutoColor);
virtual void drawTextItem(const QPointF &p, const QTextItem &textItem);
@@ -196,7 +197,8 @@ public:
void fill(const QVectorPath &path);
void stroke(const QVectorPath &path, const QPen &pen);
void drawTexture(const QGLRect& dest, const QGLRect& src, const QSize &textureSize, bool opaque, bool pattern = false);
- void drawPixmapFragments(const QPainter::Fragment *fragments, int fragmentCount, const QPixmap &pixmap, QPainter::FragmentHints hints);
+ void drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap,
+ QPainter::PixmapFragmentHints hints);
void drawCachedGlyphs(QFontEngineGlyphCache::Type glyphType, QStaticTextItem *staticTextItem,
bool includeMatrixInCache);
diff --git a/src/opengl/qgl_egl.cpp b/src/opengl/qgl_egl.cpp
index 3addea1..3d146b7 100644
--- a/src/opengl/qgl_egl.cpp
+++ b/src/opengl/qgl_egl.cpp
@@ -40,49 +40,78 @@
****************************************************************************/
#include <QtOpenGL/qgl.h>
+#include <QtOpenGL/qglpixelbuffer.h>
#include "qgl_p.h"
#include "qgl_egl_p.h"
+#include "qglpixelbuffer_p.h"
+
+#ifdef Q_WS_X11
+#include <QtGui/private/qpixmap_x11_p.h>
+#endif
QT_BEGIN_NAMESPACE
-// Set device configuration attributes from a QGLFormat instance.
-void qt_egl_set_format(QEglProperties& props, int deviceType, const QGLFormat& f)
+void qt_eglproperties_set_glformat(QEglProperties& eglProperties, const QGLFormat& glFormat)
{
- if (deviceType == QInternal::Pixmap || deviceType == QInternal::Image)
- props.setValue(EGL_SURFACE_TYPE, EGL_PIXMAP_BIT);
- else if (deviceType == QInternal::Pbuffer)
- props.setValue(EGL_SURFACE_TYPE, EGL_PBUFFER_BIT);
- else
- props.setValue(EGL_SURFACE_TYPE, EGL_WINDOW_BIT);
-
- // Set the pixel format to that contained in the QGLFormat
- // if the system hasn't already chosen a fixed format to
- // match the pixmap, widget, etc.
- if (props.value(EGL_RED_SIZE) == 0 || f.redBufferSize() != -1)
- props.setValue(EGL_RED_SIZE, f.redBufferSize() == -1 ? 1 : f.redBufferSize());
- if (props.value(EGL_GREEN_SIZE) == 0 || f.greenBufferSize() != -1)
- props.setValue(EGL_GREEN_SIZE, f.greenBufferSize() == -1 ? 1 : f.greenBufferSize());
- if (props.value(EGL_BLUE_SIZE) == 0 || f.blueBufferSize() != -1)
- props.setValue(EGL_BLUE_SIZE, f.blueBufferSize() == -1 ? 1 : f.blueBufferSize());
- if (f.alpha()) {
- if (props.value(EGL_ALPHA_SIZE) == 0 || f.alphaBufferSize() != -1)
- props.setValue(EGL_ALPHA_SIZE, f.alphaBufferSize() == -1 ? 1 : f.alphaBufferSize());
- }
+ int redSize = glFormat.redBufferSize();
+ int greenSize = glFormat.greenBufferSize();
+ int blueSize = glFormat.blueBufferSize();
+ int alphaSize = glFormat.alphaBufferSize();
+ int depthSize = glFormat.depthBufferSize();
+ int stencilSize = glFormat.stencilBufferSize();
+ int sampleCount = glFormat.samples();
- if (f.depth())
- props.setValue(EGL_DEPTH_SIZE, f.depthBufferSize() == -1 ? 1 : f.depthBufferSize());
- if (f.stencil())
- props.setValue(EGL_STENCIL_SIZE, f.stencilBufferSize() == -1 ? 1 : f.stencilBufferSize());
- if (f.sampleBuffers()) {
- props.setValue(EGL_SAMPLE_BUFFERS, 1);
- props.setValue(EGL_SAMPLES, f.samples() == -1 ? 1 : f.samples());
- } else {
- props.setValue(EGL_SAMPLE_BUFFERS, 0);
+ // QGLFormat uses a magic value of -1 to indicate "don't care", even when a buffer of that
+ // type has been requested. So we must check QGLFormat's booleans too if size is -1:
+ if (glFormat.alpha() && alphaSize <= 0) {
+ qDebug("QGLFormat::alpha() returned true");
+ alphaSize = 1;
}
- if (deviceType == QInternal::Widget)
- props.setValue(EGL_LEVEL, f.plane());
+ if (glFormat.depth() && depthSize <= 0)
+ depthSize = 1;
+ if (glFormat.stencil() && stencilSize <= 0)
+ stencilSize = 1;
+ if (glFormat.sampleBuffers() && sampleCount <= 0)
+ sampleCount = 1;
+
+ // We want to make sure 16-bit configs are chosen over 32-bit configs as they will provide
+ // the best performance. The EGL config selection algorithm is a bit stange in this regard:
+ // The selection criteria for EGL_BUFFER_SIZE is "AtLeast", so we can't use it to discard
+ // 32-bit configs completely from the selection. So it then comes to the sorting algorithm.
+ // The red/green/blue sizes have a sort priority of 3, so they are sorted by first. The sort
+ // order is special and described as "by larger _total_ number of color bits.". So EGL will
+ // put 32-bit configs in the list before the 16-bit configs. However, the spec also goes on
+ // to say "If the requested number of bits in attrib_list for a particular component is 0,
+ // then the number of bits for that component is not considered". This part of the spec also
+ // seems to imply that setting the red/green/blue bits to zero means none of the components
+ // are considered and EGL disregards the entire sorting rule. It then looks to the next
+ // highest priority rule, which is EGL_BUFFER_SIZE. Despite the selection criteria being
+ // "AtLeast" for EGL_BUFFER_SIZE, it's sort order is "smaller" meaning 16-bit configs are
+ // put in the list before 32-bit configs. So, to make sure 16-bit is preffered over 32-bit,
+ // we must set the red/green/blue sizes to zero. This has an unfortunate consequence that
+ // if the application sets the red/green/blue size to 5/6/5 on the QGLFormat, they will
+ // probably get a 32-bit config, even when there's an RGB565 config avaliable. Oh well.
+
+ // Now normalize the values so -1 becomes 0
+ redSize = redSize > 0 ? redSize : 0;
+ greenSize = greenSize > 0 ? greenSize : 0;
+ blueSize = blueSize > 0 ? blueSize : 0;
+ alphaSize = alphaSize > 0 ? alphaSize : 0;
+ depthSize = depthSize > 0 ? depthSize : 0;
+ stencilSize = stencilSize > 0 ? stencilSize : 0;
+ sampleCount = sampleCount > 0 ? sampleCount : 0;
+
+ eglProperties.setValue(EGL_RED_SIZE, redSize);
+ eglProperties.setValue(EGL_GREEN_SIZE, greenSize);
+ eglProperties.setValue(EGL_BLUE_SIZE, blueSize);
+ eglProperties.setValue(EGL_ALPHA_SIZE, alphaSize);
+ eglProperties.setValue(EGL_DEPTH_SIZE, depthSize);
+ eglProperties.setValue(EGL_STENCIL_SIZE, stencilSize);
+ eglProperties.setValue(EGL_SAMPLES, sampleCount);
+ eglProperties.setValue(EGL_SAMPLE_BUFFERS, sampleCount ? 1 : 0);
}
+
// Updates "format" with the parameters of the selected configuration.
void qt_egl_update_format(const QEglContext& context, QGLFormat& format)
{
@@ -126,7 +155,7 @@ void qt_egl_update_format(const QEglContext& context, QGLFormat& format)
// Clear the EGL error state because some of the above may
// have errored out because the attribute is not applicable
// to the surface type. Such errors don't matter.
- context.clearError();
+ QEgl::clearError();
}
bool QGLFormat::hasOpenGL()
@@ -158,12 +187,12 @@ void QGLContext::reset()
void QGLContext::makeCurrent()
{
Q_D(QGLContext);
- if (!d->valid || !d->eglContext || d->eglSurface == EGL_NO_SURFACE) {
+ if (!d->valid || !d->eglContext || d->eglSurfaceForDevice() == EGL_NO_SURFACE) {
qWarning("QGLContext::makeCurrent(): Cannot make invalid context current");
return;
}
- if (d->eglContext->makeCurrent(d->eglSurface))
+ if (d->eglContext->makeCurrent(d->eglSurfaceForDevice()))
QGLContextPrivate::setCurrentContext(this);
}
@@ -183,7 +212,7 @@ void QGLContext::swapBuffers() const
if (!d->valid || !d->eglContext)
return;
- d->eglContext->swapBuffers(d->eglSurface);
+ d->eglContext->swapBuffers(d->eglSurfaceForDevice());
}
void QGLContextPrivate::destroyEglSurfaceForDevice()
@@ -206,6 +235,30 @@ void QGLContextPrivate::destroyEglSurfaceForDevice()
}
}
+EGLSurface QGLContextPrivate::eglSurfaceForDevice() const
+{
+ // If a QPixmapData had to create the QGLContext, we don't have a paintDevice
+ if (!paintDevice)
+ return eglSurface;
+
+#ifdef Q_WS_X11
+ if (paintDevice->devType() == QInternal::Pixmap) {
+ QPixmapData *pmd = static_cast<QPixmap*>(paintDevice)->data_ptr().data();
+ if (pmd->classId() == QPixmapData::X11Class) {
+ QX11PixmapData* x11PixmapData = static_cast<QX11PixmapData*>(pmd);
+ return (EGLSurface)x11PixmapData->gl_surface;
+ }
+ }
+#endif
+
+ if (paintDevice->devType() == QInternal::Pbuffer) {
+ QGLPixelBuffer* pbuf = static_cast<QGLPixelBuffer*>(paintDevice);
+ return pbuf->d_func()->pbuf;
+ }
+
+ return eglSurface;
+}
+
void QGLWidget::setMouseTracking(bool enable)
{
QWidget::setMouseTracking(enable);
diff --git a/src/opengl/qgl_egl_p.h b/src/opengl/qgl_egl_p.h
index c503724..6b65227 100644
--- a/src/opengl/qgl_egl_p.h
+++ b/src/opengl/qgl_egl_p.h
@@ -53,15 +53,15 @@
// We mean it.
//
-#include <QtGui/private/qegl_p.h>
+#include <QtGui/private/qeglcontext_p.h>
+#include <QtGui/private/qeglproperties_p.h>
QT_BEGIN_NAMESPACE
class QGLFormat;
-void qt_egl_set_format(QEglProperties& props, int deviceType, const QGLFormat& f);
+void qt_eglproperties_set_glformat(QEglProperties& props, const QGLFormat& format);
void qt_egl_update_format(const QEglContext& context, QGLFormat& format);
-void qt_egl_add_platform_config(QEglProperties& props, QPaintDevice *device);
QT_END_NAMESPACE
diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h
index ecd8b43..ed34f79 100644
--- a/src/opengl/qgl_p.h
+++ b/src/opengl/qgl_p.h
@@ -64,14 +64,8 @@
#include "qcache.h"
#include "qglpaintdevice_p.h"
-#ifdef QT_OPENGL_ES
-QT_BEGIN_INCLUDE_NAMESPACE
-#if defined(QT_OPENGL_ES_2)
-#include <EGL/egl.h>
-#else
-#include <GLES/egl.h>
-#endif
-QT_END_INCLUDE_NAMESPACE
+#if defined(QT_OPENGL_ES) || defined(QT_OPENGL_ES_2)
+#include <QtGui/private/qegl_p.h>
#endif
QT_BEGIN_NAMESPACE
@@ -356,6 +350,7 @@ public:
QEglContext *eglContext;
EGLSurface eglSurface;
void destroyEglSurfaceForDevice();
+ EGLSurface eglSurfaceForDevice() const;
#elif defined(Q_WS_X11) || defined(Q_WS_MAC)
void* cx;
#endif
diff --git a/src/opengl/qgl_qws.cpp b/src/opengl/qgl_qws.cpp
index fd17a27..f72f051 100644
--- a/src/opengl/qgl_qws.cpp
+++ b/src/opengl/qgl_qws.cpp
@@ -119,21 +119,6 @@ bool QGLFormat::hasOpenGLOverlays()
return false;
}
-void qt_egl_add_platform_config(QEglProperties& props, QPaintDevice *device)
-{
- // Find the QGLScreen for this paint device.
- QGLScreen *glScreen = glScreenForDevice(device);
- if (!glScreen) {
- qWarning("QGLContext::chooseContext(): The screen is not a QGLScreen");
- return;
- }
- int devType = device->devType();
- if (devType == QInternal::Image)
- props.setPixelFormat(static_cast<QImage *>(device)->format());
- else
- props.setPixelFormat(glScreen->pixelFormat());
-}
-
static EGLSurface qt_egl_create_surface
(QEglContext *context, QPaintDevice *device,
const QEglProperties *properties = 0)
@@ -201,8 +186,9 @@ bool QGLContext::chooseContext(const QGLContext* shareContext)
// Construct the configuration we need for this surface.
QEglProperties configProps;
- qt_egl_add_platform_config(configProps, device());
- qt_egl_set_format(configProps, devType, d->glFormat);
+ qt_eglproperties_set_glformat(configProps, d->glFormat);
+ configProps.setDeviceType(devType);
+ configProps.setPaintDeviceFormat(device());
configProps.setRenderableType(QEgl::OpenGL);
// Search for a matching configuration, reducing the complexity
diff --git a/src/opengl/qgl_wince.cpp b/src/opengl/qgl_wince.cpp
index f81115c..3bf7f3a 100644
--- a/src/opengl/qgl_wince.cpp
+++ b/src/opengl/qgl_wince.cpp
@@ -54,7 +54,8 @@
#include <windows.h>
-#include <private/qegl_p.h>
+#include <private/qeglproperties_p.h>
+#include <private/qeglcontext_p.h>
#include <private/qgl_egl_p.h>
#include <private/qgl_cl_p.h>
@@ -121,16 +122,6 @@ QGLTemporaryContext::~QGLTemporaryContext()
QGLFormat Win32/WGL-specific code
*****************************************************************************/
-void qt_egl_add_platform_config(QEglProperties& props, QPaintDevice *device)
-{
- int devType = device->devType();
- if (devType == QInternal::Image)
- props.setPixelFormat(static_cast<QImage *>(device)->format());
- else
- props.setPixelFormat(QImage::Format_RGB16);
-}
-
-
static bool opengl32dll = false;
bool QGLFormat::hasOpenGLOverlays()
@@ -158,8 +149,9 @@ bool QGLContext::chooseContext(const QGLContext* shareContext)
// Construct the configuration we need for this surface.
QEglProperties configProps;
- qt_egl_add_platform_config(configProps, device());
- qt_egl_set_format(configProps, devType, d->glFormat);
+ qt_eglproperties_set_glformat(configProps, d->glFormat);
+ configProps.setDeviceType(devType);
+ configProps.setPaintDeviceFormat(device());
configProps.setRenderableType(QEgl::OpenGL);
// Search for a matching configuration, reducing the complexity
diff --git a/src/opengl/qgl_x11.cpp b/src/opengl/qgl_x11.cpp
index f0b06ef5..4fa1467 100644
--- a/src/opengl/qgl_x11.cpp
+++ b/src/opengl/qgl_x11.cpp
@@ -1753,7 +1753,7 @@ QGLTexture *QGLContextPrivate::bindTextureFromNativePixmap(QPixmapData *pmd, con
if (!glxPixmap)
return 0;
- pixmapData->gl_surface = (Qt::HANDLE)glxPixmap;
+ pixmapData->gl_surface = (void*)glxPixmap;
// Make sure the cleanup hook gets called so we can delete the glx pixmap
QImagePixmapCleanupHooks::enableCleanupHooks(pixmapData);
diff --git a/src/opengl/qgl_x11egl.cpp b/src/opengl/qgl_x11egl.cpp
index 3d183ee..a7c92cf 100644
--- a/src/opengl/qgl_x11egl.cpp
+++ b/src/opengl/qgl_x11egl.cpp
@@ -42,20 +42,17 @@
#include "qgl.h"
#include <private/qt_x11_p.h>
#include <private/qpixmap_x11_p.h>
-#include <private/qimagepixmapcleanuphooks_p.h>
#include <private/qgl_p.h>
#include <private/qpaintengine_opengl_p.h>
#include "qgl_egl_p.h"
#include "qcolormap.h"
#include <QDebug>
+#include <QPixmap>
QT_BEGIN_NAMESPACE
-bool qt_egl_setup_x11_visual(XVisualInfo &vi, EGLDisplay display, EGLConfig config,
- const QX11Info &x11Info, bool useArgbVisual);
-
/*
QGLTemporaryContext implementation
*/
@@ -79,12 +76,7 @@ QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)
d->surface = 0;
int screen = 0;
- d->display = eglGetDisplay(EGLNativeDisplayType(X11->display));
-
- if (!eglInitialize(d->display, NULL, NULL)) {
- qWarning("QGLTemporaryContext: Unable to initialize EGL display.");
- return;
- }
+ d->display = QEgl::display();
EGLConfig config;
int numConfigs = 0;
@@ -107,15 +99,7 @@ QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)
int numVisuals;
EGLint id = 0;
- eglGetConfigAttrib(d->display, config, EGL_NATIVE_VISUAL_ID, &id);
- if (id == 0) {
- // EGL_NATIVE_VISUAL_ID is optional and might not be supported
- // on some implementations - we'll have to do it the hard way
- QX11Info xinfo;
- qt_egl_setup_x11_visual(visualInfo, d->display, config, xinfo, false);
- } else {
- visualInfo.visualid = id;
- }
+ visualInfo.visualid = QEgl::getCompatibleVisualId(config);
vi = XGetVisualInfo(X11->display, VisualIDMask, &visualInfo, &numVisuals);
if (!vi || numVisuals < 1) {
qWarning("QGLTemporaryContext: Unable to get X11 visual info id.");
@@ -170,12 +154,6 @@ bool QGLFormat::hasOpenGLOverlays()
return false;
}
-void qt_egl_add_platform_config(QEglProperties& props, QPaintDevice *device)
-{
- if (device->devType() == QInternal::Image)
- props.setPixelFormat(static_cast<QImage *>(device)->format());
-}
-
// Chooses the EGL config and creates the EGL context
bool QGLContext::chooseContext(const QGLContext* shareContext)
{
@@ -186,54 +164,49 @@ bool QGLContext::chooseContext(const QGLContext* shareContext)
int devType = device()->devType();
- // Get the display and initialize it.
+ QX11PixmapData *x11PixmapData = 0;
+ if (devType == QInternal::Pixmap) {
+ QPixmapData *pmd = static_cast<QPixmap*>(device())->data_ptr().data();
+ if (pmd->classId() == QPixmapData::X11Class)
+ x11PixmapData = static_cast<QX11PixmapData*>(pmd);
+ else {
+ // TODO: Replace the pixmap's data with a new QX11PixmapData
+ qWarning("WARNING: Creating a QGLContext on a QPixmap is only supported for X11 pixmap backend");
+ return false;
+ }
+ } else if ((devType != QInternal::Widget) && (devType != QInternal::Pbuffer)) {
+ qWarning("WARNING: Creating a QGLContext not supported on device type %d", devType);
+ return false;
+ }
+
+ // Only create the eglContext if we don't already have one:
if (d->eglContext == 0) {
d->eglContext = new QEglContext();
d->eglContext->setApi(QEgl::OpenGL);
+ // If the device is a widget with WA_TranslucentBackground set, make sure the glFormat
+ // has the alpha channel option set:
+ if (devType == QInternal::Widget) {
+ QWidget* widget = static_cast<QWidget*>(device());
+ if (widget->testAttribute(Qt::WA_TranslucentBackground))
+ d->glFormat.setAlpha(true);
+ }
+
// Construct the configuration we need for this surface.
QEglProperties configProps;
- qt_egl_set_format(configProps, devType, d->glFormat);
- qt_egl_add_platform_config(configProps, device());
+ configProps.setDeviceType(devType);
configProps.setRenderableType(QEgl::OpenGL);
-
-#if We_have_an_EGL_library_which_bothers_to_check_EGL_BUFFER_SIZE
- if (device()->depth() == 16 && configProps.value(EGL_ALPHA_SIZE) <= 0) {
- qDebug("Setting EGL_BUFFER_SIZE to 16");
- configProps.setValue(EGL_BUFFER_SIZE, 16);
- configProps.setValue(EGL_ALPHA_SIZE, 0);
- }
+ qt_eglproperties_set_glformat(configProps, d->glFormat);
if (!d->eglContext->chooseConfig(configProps, QEgl::BestPixelFormat)) {
delete d->eglContext;
d->eglContext = 0;
return false;
}
-#else
- QEgl::PixelFormatMatch matchType = QEgl::BestPixelFormat;
- if ((device()->depth() == 16) && configProps.value(EGL_ALPHA_SIZE) == 0) {
- configProps.setValue(EGL_RED_SIZE, 5);
- configProps.setValue(EGL_GREEN_SIZE, 6);
- configProps.setValue(EGL_BLUE_SIZE, 5);
- configProps.setValue(EGL_ALPHA_SIZE, 0);
- matchType = QEgl::ExactPixelFormat;
- }
-
- // Search for a matching configuration, reducing the complexity
- // each time until we get something that matches.
- if (!d->eglContext->chooseConfig(configProps, matchType)) {
- delete d->eglContext;
- d->eglContext = 0;
- return false;
- }
-#endif
-
-// qDebug("QGLContext::chooseContext() - using EGL config %d:", d->eglContext->config());
-// qDebug() << QEglProperties(d->eglContext->config()).toString();
// Create a new context for the configuration.
- if (!d->eglContext->createContext
- (shareContext ? shareContext->d_func()->eglContext : 0)) {
+ QEglContext* eglSharedContext = shareContext ? shareContext->d_func()->eglContext : 0;
+ if (!d->eglContext->createContext(eglSharedContext)) {
delete d->eglContext;
d->eglContext = 0;
return false;
@@ -241,16 +214,34 @@ bool QGLContext::chooseContext(const QGLContext* shareContext)
d->sharing = d->eglContext->isSharing();
if (d->sharing && shareContext)
const_cast<QGLContext *>(shareContext)->d_func()->sharing = true;
-
-#if defined(EGL_VERSION_1_1)
- if (d->glFormat.swapInterval() != -1 && devType == QInternal::Widget)
- eglSwapInterval(d->eglContext->display(), d->glFormat.swapInterval());
-#endif
}
// Inform the higher layers about the actual format properties.
qt_egl_update_format(*(d->eglContext), d->glFormat);
+
+ // Do don't create the EGLSurface for everything.
+ // QWidget - yes, create the EGLSurface and store it in QGLContextPrivate::eglSurface
+ // QGLWidget - yes, create the EGLSurface and store it in QGLContextPrivate::eglSurface
+ // QPixmap - yes, create the EGLSurface but store it in QX11PixmapData::gl_surface
+ // QGLPixelBuffer - no, it creates the surface itself and stores it in QGLPixelBufferPrivate::pbuf
+
+ if (devType == QInternal::Widget) {
+ if (d->eglSurface != EGL_NO_SURFACE)
+ eglDestroySurface(d->eglContext->display(), d->eglSurface);
+ d->eglSurface = QEgl::createSurface(device(), d->eglContext->config());
+ XFlush(X11->display);
+ setWindowCreated(true);
+ }
+
+ if (x11PixmapData) {
+ // TODO: Actually check to see if the existing surface can be re-used
+ if (x11PixmapData->gl_surface)
+ eglDestroySurface(d->eglContext->display(), (EGLSurface)x11PixmapData->gl_surface);
+
+ x11PixmapData->gl_surface = (void*)QEgl::createSurface(device(), d->eglContext->config());
+ }
+
return true;
}
@@ -281,142 +272,6 @@ void QGLWidget::updateOverlayGL()
//handle overlay
}
-//#define QT_DEBUG_X11_VISUAL_SELECTION 1
-
-bool qt_egl_setup_x11_visual(XVisualInfo &vi, EGLDisplay display, EGLConfig config, const QX11Info &x11Info, bool useArgbVisual)
-{
- bool foundVisualIsArgb = useArgbVisual;
-
-#ifdef QT_DEBUG_X11_VISUAL_SELECTION
- qDebug("qt_egl_setup_x11_visual() - useArgbVisual=%d", useArgbVisual);
-#endif
-
- memset(&vi, 0, sizeof(XVisualInfo));
-
- EGLint eglConfigColorSize;
- eglGetConfigAttrib(display, config, EGL_BUFFER_SIZE, &eglConfigColorSize);
-
- // Check to see if EGL is suggesting an appropriate visual id:
- EGLint nativeVisualId;
- eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &nativeVisualId);
- vi.visualid = nativeVisualId;
-
- if (vi.visualid) {
- // EGL has suggested a visual id, so get the rest of the visual info for that id:
- XVisualInfo *chosenVisualInfo;
- int matchingCount = 0;
- chosenVisualInfo = XGetVisualInfo(x11Info.display(), VisualIDMask, &vi, &matchingCount);
- if (chosenVisualInfo) {
-#if !defined(QT_NO_XRENDER)
- if (useArgbVisual) {
- // Check to make sure the visual provided by EGL is ARGB
- XRenderPictFormat *format;
- format = XRenderFindVisualFormat(x11Info.display(), chosenVisualInfo->visual);
- if (format->type == PictTypeDirect && format->direct.alphaMask) {
-#ifdef QT_DEBUG_X11_VISUAL_SELECTION
- qDebug("Using ARGB X Visual ID (%d) provided by EGL", (int)vi.visualid);
-#endif
- foundVisualIsArgb = true;
- vi = *chosenVisualInfo;
- }
- else {
- qWarning("Warning: EGL suggested using X visual ID %d for config %d, but this is not ARGB",
- nativeVisualId, (int)config);
- vi.visualid = 0;
- }
- } else
-#endif
- {
- if (eglConfigColorSize == chosenVisualInfo->depth) {
-#ifdef QT_DEBUG_X11_VISUAL_SELECTION
- qDebug("Using opaque X Visual ID (%d) provided by EGL", (int)vi.visualid);
-#endif
- vi = *chosenVisualInfo;
- } else
- qWarning("Warning: EGL suggested using X visual ID %d (%d bpp) for config %d (%d bpp), but the depths do not match!",
- nativeVisualId, chosenVisualInfo->depth, (int)config, eglConfigColorSize);
- }
- XFree(chosenVisualInfo);
- }
- else {
- qWarning("Warning: EGL suggested using X visual ID %d for config %d, but this seems to be invalid!",
- nativeVisualId, (int)config);
- vi.visualid = 0;
- }
- }
-
- // If EGL does not know the visual ID, so try to select an appropriate one ourselves, first
- // using XRender if we're supposed to have an alpha, then falling back to XGetVisualInfo
-
-#if !defined(QT_NO_XRENDER)
- if (vi.visualid == 0 && useArgbVisual) {
- // Try to use XRender to find an ARGB visual we can use
- vi.screen = x11Info.screen();
- vi.depth = 32; //### We might at some point (soon) get ARGB4444
- vi.c_class = TrueColor;
- XVisualInfo *matchingVisuals;
- int matchingCount = 0;
- matchingVisuals = XGetVisualInfo(x11Info.display(),
- VisualScreenMask|VisualDepthMask|VisualClassMask,
- &vi, &matchingCount);
-
- for (int i = 0; i < matchingCount; ++i) {
- XRenderPictFormat *format;
- format = XRenderFindVisualFormat(x11Info.display(), matchingVisuals[i].visual);
- if (format->type == PictTypeDirect && format->direct.alphaMask) {
- vi = matchingVisuals[i];
- foundVisualIsArgb = true;
-#ifdef QT_DEBUG_X11_VISUAL_SELECTION
- qDebug("Using X Visual ID (%d) for ARGB visual as provided by XRender", (int)vi.visualid);
-#endif
- break;
- }
- }
- XFree(matchingVisuals);
- }
-#endif
-
- if (vi.visualid == 0) {
- EGLint depth;
- eglGetConfigAttrib(display, config, EGL_BUFFER_SIZE, &depth);
- int err;
- err = XMatchVisualInfo(x11Info.display(), x11Info.screen(), depth, TrueColor, &vi);
- if (err == 0) {
- qWarning("Warning: Can't find an X visual which matches the EGL config(%d)'s depth (%d)!",
- (int)config, depth);
- depth = x11Info.depth();
- err = XMatchVisualInfo(x11Info.display(), x11Info.screen(), depth, TrueColor, &vi);
- if (err == 0) {
- qWarning("Error: Couldn't get any matching X visual!");
- return false;
- } else
- qWarning(" - Falling back to X11 suggested depth (%d)", depth);
- }
-#ifdef QT_DEBUG_X11_VISUAL_SELECTION
- else
- qDebug("Using X Visual ID (%d) for EGL provided depth (%d)", (int)vi.visualid, depth);
-#endif
-
- // Don't try to use ARGB now unless the visual is 32-bit - even then it might stil fail :-(
- if (useArgbVisual)
- foundVisualIsArgb = vi.depth == 32; //### We might at some point (soon) get ARGB4444
- }
-
-#ifdef QT_DEBUG_X11_VISUAL_SELECTION
- qDebug("Visual Info:");
- qDebug(" bits_per_rgb=%d", vi.bits_per_rgb);
- qDebug(" red_mask=0x%x", vi.red_mask);
- qDebug(" green_mask=0x%x", vi.green_mask);
- qDebug(" blue_mask=0x%x", vi.blue_mask);
- qDebug(" colormap_size=%d", vi.colormap_size);
- qDebug(" c_class=%d", vi.c_class);
- qDebug(" depth=%d", vi.depth);
- qDebug(" screen=%d", vi.screen);
- qDebug(" visualid=%d", vi.visualid);
-#endif
- return foundVisualIsArgb;
-}
-
void QGLWidget::setContext(QGLContext *context, const QGLContext* shareContext, bool deleteOldContext)
{
Q_D(QGLWidget);
@@ -434,20 +289,6 @@ void QGLWidget::setContext(QGLContext *context, const QGLContext* shareContext,
QGLContext* oldcx = d->glcx;
d->glcx = context;
- if (parentWidget()) {
- // force creation of delay-created widgets
- parentWidget()->winId();
- if (parentWidget()->x11Info().screen() != x11Info().screen())
- d_func()->xinfo = parentWidget()->d_func()->xinfo;
- }
-
- // If the application has set WA_TranslucentBackground and not explicitly set
- // the alpha buffer size to zero, modify the format so it have an alpha channel
- QGLFormat& fmt = d->glcx->d_func()->glFormat;
- const bool tryArgbVisual = testAttribute(Qt::WA_TranslucentBackground) || fmt.alpha();
- if (tryArgbVisual && fmt.alphaBufferSize() == -1)
- fmt.setAlphaBufferSize(1);
-
bool createFailed = false;
if (!d->glcx->isValid()) {
// Create the QGLContext here, which in turn chooses the EGL config
@@ -461,63 +302,8 @@ void QGLWidget::setContext(QGLContext *context, const QGLContext* shareContext,
return;
}
- if (d->glcx->windowCreated() || d->glcx->deviceIsPixmap()) {
- if (deleteOldContext)
- delete oldcx;
- return;
- }
-
- bool visible = isVisible();
- if (visible)
- hide();
-
- XVisualInfo vi;
- QEglContext *eglContext = d->glcx->d_func()->eglContext;
- bool usingArgbVisual = qt_egl_setup_x11_visual(vi, eglContext->display(), eglContext->config(),
- x11Info(), tryArgbVisual);
-
- XSetWindowAttributes a;
-
- Window p = RootWindow(x11Info().display(), x11Info().screen());
- if (parentWidget())
- p = parentWidget()->winId();
-
- QColormap colmap = QColormap::instance(vi.screen);
- a.background_pixel = colmap.pixel(palette().color(backgroundRole()));
- a.border_pixel = colmap.pixel(Qt::black);
-
- unsigned int valueMask = CWBackPixel|CWBorderPixel;
- if (usingArgbVisual) {
- a.colormap = XCreateColormap(x11Info().display(), p, vi.visual, AllocNone);
- valueMask |= CWColormap;
- }
-
- Window w = XCreateWindow(x11Info().display(), p, x(), y(), width(), height(),
- 0, vi.depth, InputOutput, vi.visual, valueMask, &a);
-
- if (deleteOldContext)
- delete oldcx;
- oldcx = 0;
-
- create(w); // Create with the ID of the window we've just created
-
-
- // Create the EGL surface to draw into.
- QGLContextPrivate *ctxpriv = d->glcx->d_func();
- ctxpriv->eglSurface = ctxpriv->eglContext->createSurface(this);
- if (ctxpriv->eglSurface == EGL_NO_SURFACE) {
- delete ctxpriv->eglContext;
- ctxpriv->eglContext = 0;
- return;
- }
-
- d->eglSurfaceWindowId = w; // Remember the window id we created the surface for
- if (visible)
- show();
-
- XFlush(X11->display);
- d->glcx->setWindowCreated(true);
+ d->eglSurfaceWindowId = winId(); // Remember the window id we created the surface for
}
void QGLWidgetPrivate::init(QGLContext *context, const QGLWidget* shareWidget)
@@ -526,7 +312,7 @@ void QGLWidgetPrivate::init(QGLContext *context, const QGLWidget* shareWidget)
initContext(context, shareWidget);
- if(q->isValid() && glcx->format().hasOverlay()) {
+ if (q->isValid() && glcx->format().hasOverlay()) {
//no overlay
qWarning("QtOpenGL ES doesn't currently support overlays");
}
@@ -567,114 +353,6 @@ void QGLWidgetPrivate::recreateEglSurface(bool force)
}
}
-// Selects which configs should be used
-EGLConfig Q_OPENGL_EXPORT qt_chooseEGLConfigForPixmap(bool hasAlpha, bool readOnly)
-{
- // Cache the configs we select as they wont change:
- static EGLConfig roPixmapRGBConfig = 0;
- static EGLConfig roPixmapRGBAConfig = 0;
- static EGLConfig rwPixmapRGBConfig = 0;
- static EGLConfig rwPixmapRGBAConfig = 0;
-
- EGLConfig* targetConfig;
-
- if (hasAlpha) {
- if (readOnly)
- targetConfig = &roPixmapRGBAConfig;
- else
- targetConfig = &rwPixmapRGBAConfig;
- }
- else {
- if (readOnly)
- targetConfig = &roPixmapRGBConfig;
- else
- targetConfig = &rwPixmapRGBConfig;
- }
-
- if (*targetConfig == 0) {
- QEglProperties configAttribs;
- configAttribs.setValue(EGL_SURFACE_TYPE, EGL_PIXMAP_BIT);
- configAttribs.setRenderableType(QEgl::OpenGL);
- if (hasAlpha)
- configAttribs.setValue(EGL_BIND_TO_TEXTURE_RGBA, EGL_TRUE);
- else
- configAttribs.setValue(EGL_BIND_TO_TEXTURE_RGB, EGL_TRUE);
-
- // If this is going to be a render target, it needs to have a depth, stencil & sample buffer
- if (!readOnly) {
- configAttribs.setValue(EGL_DEPTH_SIZE, 1);
- configAttribs.setValue(EGL_STENCIL_SIZE, 1);
- configAttribs.setValue(EGL_SAMPLE_BUFFERS, 1);
- }
-
- EGLint configCount = 0;
- do {
- eglChooseConfig(QEglContext::display(), configAttribs.properties(), targetConfig, 1, &configCount);
- if (configCount > 0) {
- // Got one
- qDebug() << "Found an" << (hasAlpha ? "ARGB" : "RGB") << (readOnly ? "readonly" : "target" )
- << "config (" << int(*targetConfig) << ") to create a pixmap surface:";
-
-// QEglProperties configProps(*targetConfig);
-// qDebug() << configProps.toString();
- break;
- }
- qWarning("choosePixmapConfig() - No suitible config found, reducing requirements");
- } while (configAttribs.reduceConfiguration());
- }
-
- if (*targetConfig == 0)
- qWarning("choosePixmapConfig() - Couldn't find a suitable config");
-
- return *targetConfig;
-}
-
-bool Q_OPENGL_EXPORT qt_createEGLSurfaceForPixmap(QPixmapData* pmd, bool readOnly)
-{
- Q_ASSERT(pmd->classId() == QPixmapData::X11Class);
- QX11PixmapData* pixmapData = static_cast<QX11PixmapData*>(pmd);
-
- bool hasAlpha = pixmapData->hasAlphaChannel();
-
- EGLConfig pixmapConfig = qt_chooseEGLConfigForPixmap(hasAlpha, readOnly);
-
- QEglProperties pixmapAttribs;
-
- // If the pixmap can't be bound to a texture, it's pretty useless
- pixmapAttribs.setValue(EGL_TEXTURE_TARGET, EGL_TEXTURE_2D);
- if (hasAlpha)
- pixmapAttribs.setValue(EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA);
- else
- pixmapAttribs.setValue(EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGB);
-
- EGLSurface pixmapSurface;
- pixmapSurface = eglCreatePixmapSurface(QEglContext::display(),
- pixmapConfig,
- (EGLNativePixmapType) pixmapData->handle(),
- pixmapAttribs.properties());
-// qDebug("qt_createEGLSurfaceForPixmap() created surface 0x%x for pixmap 0x%x",
-// pixmapSurface, pixmapData->handle());
- if (pixmapSurface == EGL_NO_SURFACE) {
- qWarning() << "Failed to create a pixmap surface using config" << (int)pixmapConfig
- << ":" << QEglContext::errorString(eglGetError());
- return false;
- }
-
- static bool doneOnce = false;
- if (!doneOnce) {
- // Make sure QGLTextureCache is instanciated so it can install cleanup hooks
- // which cleanup the EGL surface.
- QGLTextureCache::instance();
- doneOnce = true;
- }
-
- Q_ASSERT(sizeof(Qt::HANDLE) >= sizeof(EGLSurface)); // Just to make totally sure!
- pixmapData->gl_surface = (Qt::HANDLE)pixmapSurface;
- QImagePixmapCleanupHooks::enableCleanupHooks(pixmapData); // Make sure the cleanup hook gets called
-
- return true;
-}
-
QGLTexture *QGLContextPrivate::bindTextureFromNativePixmap(QPixmapData* pd, const qint64 key,
QGLContext::BindOptions options)
@@ -693,8 +371,8 @@ QGLTexture *QGLContextPrivate::bindTextureFromNativePixmap(QPixmapData* pd, cons
if (!checkedForTFP) {
// Check for texture_from_pixmap egl extension
checkedForTFP = true;
- if (eglContext->hasExtension("EGL_NOKIA_texture_from_pixmap") ||
- eglContext->hasExtension("EGL_EXT_texture_from_pixmap"))
+ if (QEgl::hasExtension("EGL_NOKIA_texture_from_pixmap") ||
+ QEgl::hasExtension("EGL_EXT_texture_from_pixmap"))
{
qDebug("Found texture_from_pixmap EGL extension!");
haveTFP = true;
@@ -717,8 +395,13 @@ QGLTexture *QGLContextPrivate::bindTextureFromNativePixmap(QPixmapData* pd, cons
}
if (pixmapData->gl_surface == 0) {
- bool success = qt_createEGLSurfaceForPixmap(pixmapData, true);
- if (!success) {
+ EGLConfig config = QEgl::defaultConfig(QInternal::Pixmap,
+ QEgl::OpenGL,
+ hasAlpha ? QEgl::Translucent : QEgl::NoOptions);
+
+ QPixmap tmpPixmap(pixmapData); //###
+ pixmapData->gl_surface = (void*)QEgl::createSurface(&tmpPixmap, config);
+ if (pixmapData->gl_surface == (void*)EGL_NO_SURFACE) {
haveTFP = false;
return 0;
}
@@ -734,9 +417,9 @@ QGLTexture *QGLContextPrivate::bindTextureFromNativePixmap(QPixmapData* pd, cons
EGLBoolean success;
success = eglBindTexImage(eglContext->display(), (EGLSurface)pixmapData->gl_surface, EGL_BACK_BUFFER);
if (success == EGL_FALSE) {
- qWarning() << "eglBindTexImage() failed:" << eglContext->errorString(eglGetError());
+ qWarning() << "eglBindTexImage() failed:" << QEgl::errorString();
eglDestroySurface(eglContext->display(), (EGLSurface)pixmapData->gl_surface);
- pixmapData->gl_surface = (Qt::HANDLE)EGL_NO_SURFACE;
+ pixmapData->gl_surface = (void*)EGL_NO_SURFACE;
haveTFP = false;
return 0;
}
@@ -757,10 +440,10 @@ void QGLContextPrivate::destroyGlSurfaceForPixmap(QPixmapData* pmd)
QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);
if (pixmapData->gl_surface) {
EGLBoolean success;
- success = eglDestroySurface(QEglContext::display(), (EGLSurface)pixmapData->gl_surface);
+ success = eglDestroySurface(QEgl::display(), (EGLSurface)pixmapData->gl_surface);
if (success == EGL_FALSE) {
qWarning() << "destroyGlSurfaceForPixmap() - Error deleting surface: "
- << QEglContext::errorString(eglGetError());
+ << QEgl::errorString();
}
pixmapData->gl_surface = 0;
}
@@ -772,12 +455,12 @@ void QGLContextPrivate::unbindPixmapFromTexture(QPixmapData* pmd)
QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);
if (pixmapData->gl_surface) {
EGLBoolean success;
- success = eglReleaseTexImage(QEglContext::display(),
+ success = eglReleaseTexImage(QEgl::display(),
(EGLSurface)pixmapData->gl_surface,
EGL_BACK_BUFFER);
if (success == EGL_FALSE) {
qWarning() << "unbindPixmapFromTexture() - Unable to release bound texture: "
- << QEglContext::errorString(eglGetError());
+ << QEgl::errorString();
}
}
}
diff --git a/src/opengl/qglpixelbuffer.h b/src/opengl/qglpixelbuffer.h
index 3304dd8..d9c7e3e 100644
--- a/src/opengl/qglpixelbuffer.h
+++ b/src/opengl/qglpixelbuffer.h
@@ -112,6 +112,7 @@ private:
friend class QGLWindowSurface;
friend class QGLPaintDevice;
friend class QGLPBufferGLPaintDevice;
+ friend class QGLContextPrivate;
};
QT_END_NAMESPACE
diff --git a/src/opengl/qglpixelbuffer_egl.cpp b/src/opengl/qglpixelbuffer_egl.cpp
index 954049d..ee0714f 100644
--- a/src/opengl/qglpixelbuffer_egl.cpp
+++ b/src/opengl/qglpixelbuffer_egl.cpp
@@ -82,7 +82,8 @@ bool QGLPixelBufferPrivate::init(const QSize &size, const QGLFormat &f, QGLWidge
#endif
} else {
QEglProperties configProps;
- qt_egl_set_format(configProps, QInternal::Pbuffer, f);
+ qt_eglproperties_set_glformat(configProps, f);
+ configProps.setDeviceType(QInternal::Pbuffer);
configProps.setRenderableType(ctx->api());
bool ok = false;
#if QGL_RENDER_TEXTURE
@@ -137,7 +138,7 @@ bool QGLPixelBufferPrivate::init(const QSize &size, const QGLFormat &f, QGLWidge
}
#endif
if (pbuf == EGL_NO_SURFACE) {
- qWarning() << "QGLPixelBufferPrivate::init(): Unable to create EGL pbuffer surface:" << QEglContext::errorString(eglGetError());
+ qWarning() << "QGLPixelBufferPrivate::init(): Unable to create EGL pbuffer surface:" << QEgl::errorString();
return false;
}
@@ -204,11 +205,12 @@ GLuint QGLPixelBuffer::generateDynamicTexture() const
bool QGLPixelBuffer::hasOpenGLPbuffers()
{
// See if we have at least 1 configuration that matches the default format.
- EGLDisplay dpy = QEglContext::display();
+ EGLDisplay dpy = QEgl::display();
if (dpy == EGL_NO_DISPLAY)
return false;
QEglProperties configProps;
- qt_egl_set_format(configProps, QInternal::Pbuffer, QGLFormat::defaultFormat());
+ qt_eglproperties_set_glformat(configProps, QGLFormat::defaultFormat());
+ configProps.setDeviceType(QInternal::Pbuffer);
configProps.setRenderableType(QEgl::OpenGL);
do {
EGLConfig cfg = 0;
diff --git a/src/opengl/qgraphicssystem_gl.cpp b/src/opengl/qgraphicssystem_gl.cpp
index 3a399ae..a282e4c 100644
--- a/src/opengl/qgraphicssystem_gl.cpp
+++ b/src/opengl/qgraphicssystem_gl.cpp
@@ -62,7 +62,6 @@ QPixmapData *QGLGraphicsSystem::createPixmapData(QPixmapData::PixelType type) co
if (type == QPixmapData::PixmapType && QX11GLPixmapData::hasX11GLPixmaps())
return new QX11GLPixmapData();
#endif
-
return new QGLPixmapData(type);
}
diff --git a/src/opengl/qpixmapdata_x11gl_egl.cpp b/src/opengl/qpixmapdata_x11gl_egl.cpp
index 6a1d030..d7fae16 100644
--- a/src/opengl/qpixmapdata_x11gl_egl.cpp
+++ b/src/opengl/qpixmapdata_x11gl_egl.cpp
@@ -44,6 +44,7 @@
#include <private/qgl_p.h>
#include <private/qegl_p.h>
#include <private/qeglproperties_p.h>
+#include <private/qeglcontext_p.h>
#if !defined(QT_OPENGL_ES_1)
#include <private/qpaintengineex_opengl2_p.h>
@@ -57,13 +58,16 @@
QT_BEGIN_NAMESPACE
-extern EGLConfig qt_chooseEGLConfigForPixmap(bool hasAlpha, bool readOnly); // in qgl_x11egl.cpp
-extern bool qt_createEGLSurfaceForPixmap(QPixmapData* pmd, bool readOnly); // in qgl_x11egl.cpp
// On 16bpp systems, RGB & ARGB pixmaps are different bit-depths and therefore need
// different contexts:
-static EGLContext qPixmapARGBSharedEglContext = EGL_NO_CONTEXT;
-static EGLContext qPixmapRGBSharedEglContext = EGL_NO_CONTEXT;
+
+Q_GLOBAL_STATIC(QEglContext, qt_x11gl_rgbContext);
+Q_GLOBAL_STATIC(QEglContext, qt_x11gl_argbContext)
+
+QEglContext* QX11GLPixmapData::rgbContext = 0;
+QEglContext* QX11GLPixmapData::argbContext = 0;
+
bool QX11GLPixmapData::hasX11GLPixmaps()
{
@@ -75,111 +79,94 @@ bool QX11GLPixmapData::hasX11GLPixmaps()
checkedForX11Pixmaps = true;
- QX11PixmapData *argbPixmapData = 0;
- QX11PixmapData *rgbPixmapData = 0;
+ EGLint rgbConfigId;
+ EGLint argbConfigId;
+
do {
if (qgetenv("QT_USE_X11GL_PIXMAPS").isEmpty())
break;
- // Check we actually have EGL configs which support pixmaps
- EGLConfig argbConfig = qt_chooseEGLConfigForPixmap(true, false);
- EGLConfig rgbConfig = qt_chooseEGLConfigForPixmap(false, false);
+ EGLConfig rgbConfig = QEgl::defaultConfig(QInternal::Pixmap, QEgl::OpenGL, QEgl::Renderable);
+ EGLConfig argbConfig = QEgl::defaultConfig(QInternal::Pixmap, QEgl::OpenGL,
+ QEgl::Renderable | QEgl::Translucent);
- if (argbConfig == 0 || rgbConfig == 0)
- break;
+ eglGetConfigAttrib(QEgl::display(), rgbConfig, EGL_CONFIG_ID, &rgbConfigId);
+ eglGetConfigAttrib(QEgl::display(), argbConfig, EGL_CONFIG_ID, &argbConfigId);
- // Create the shared contexts:
- eglBindAPI(EGL_OPENGL_ES_API);
- EGLint contextAttribs[] = {
-#if defined(QT_OPENGL_ES_2)
- EGL_CONTEXT_CLIENT_VERSION, 2,
-#endif
- EGL_NONE
- };
- qPixmapARGBSharedEglContext = eglCreateContext(QEglContext::display(),
- argbConfig, 0, contextAttribs);
-
- if (argbConfig == rgbConfig) {
- // If the configs are the same, we can re-use the same context.
- qPixmapRGBSharedEglContext = qPixmapARGBSharedEglContext;
- } else {
- qPixmapRGBSharedEglContext = eglCreateContext(QEglContext::display(),
- rgbConfig, 0, contextAttribs);
+ if (!rgbContext) {
+ rgbContext = qt_x11gl_rgbContext();
+ rgbContext->setConfig(rgbConfig);
+ rgbContext->createContext();
}
- argbPixmapData = new QX11PixmapData(QPixmapData::PixmapType);
- argbPixmapData->resize(100, 100);
- argbPixmapData->fill(Qt::transparent); // Force ARGB
+ if (!rgbContext->isValid())
+ break;
- if (!qt_createEGLSurfaceForPixmap(argbPixmapData, false))
+ // If the configs are the same, use the same egl contexts:
+ if (rgbConfig == argbConfig)
+ argbContext = rgbContext;
+
+ if (!argbContext) {
+ argbContext = qt_x11gl_argbContext();
+ argbContext->setConfig(argbConfig);
+ argbContext->createContext();
+ }
+
+ if (!argbContext->isValid())
break;
- haveX11Pixmaps = eglMakeCurrent(QEglContext::display(),
- (EGLSurface)argbPixmapData->gl_surface,
- (EGLSurface)argbPixmapData->gl_surface,
- qPixmapARGBSharedEglContext);
+ {
+ QX11PixmapData *argbPixmapData = new QX11PixmapData(QPixmapData::PixmapType);
+ argbPixmapData->resize(100, 100);
+ argbPixmapData->fill(Qt::transparent); // Force ARGB
+ QPixmap argbPixmap(argbPixmapData);
+ EGLSurface argbPixmapSurface = QEgl::createSurface(&argbPixmap, argbConfig);
+ haveX11Pixmaps = argbContext->makeCurrent(argbPixmapSurface);
+ argbContext->doneCurrent();
+ eglDestroySurface(QEgl::display(), argbPixmapSurface);
+ }
+
if (!haveX11Pixmaps) {
- EGLint err = eglGetError();
- qWarning() << "Unable to make pixmap config current:" << err << QEglContext::errorString(err);
+ qWarning() << "Unable to make pixmap surface current:" << QEgl::errorString();
break;
}
- // If the ARGB & RGB configs are the same, we don't need to check RGB too
- if (haveX11Pixmaps && (argbConfig != rgbConfig)) {
- rgbPixmapData = new QX11PixmapData(QPixmapData::PixmapType);
+ // If the ARGB & RGB configs are different, check RGB too:
+ if (argbConfig != rgbConfig) {
+ QX11PixmapData *rgbPixmapData = new QX11PixmapData(QPixmapData::PixmapType);
rgbPixmapData->resize(100, 100);
rgbPixmapData->fill(Qt::red);
- // Try to actually create an EGL pixmap surface
- if (!qt_createEGLSurfaceForPixmap(rgbPixmapData, false))
- break;
+ QPixmap rgbPixmap(rgbPixmapData);
+ EGLSurface rgbPixmapSurface = QEgl::createSurface(&rgbPixmap, rgbConfig);
+ haveX11Pixmaps = rgbContext->makeCurrent(rgbPixmapSurface);
+ rgbContext->doneCurrent();
+ eglDestroySurface(QEgl::display(), rgbPixmapSurface);
- haveX11Pixmaps = eglMakeCurrent(QEglContext::display(),
- (EGLSurface)rgbPixmapData->gl_surface,
- (EGLSurface)rgbPixmapData->gl_surface,
- qPixmapRGBSharedEglContext);
if (!haveX11Pixmaps) {
- EGLint err = eglGetError();
- qWarning() << "Unable to make pixmap config current:" << err << QEglContext::errorString(err);
+ qWarning() << "Unable to make pixmap config current:" << QEgl::errorString();
break;
}
}
- } while (0);
-
- if (qPixmapARGBSharedEglContext || qPixmapRGBSharedEglContext) {
- eglMakeCurrent(QEglContext::display(),
- EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
- }
- if (argbPixmapData) {
- if (argbPixmapData->gl_surface)
- QGLContextPrivate::destroyGlSurfaceForPixmap(argbPixmapData);
- delete argbPixmapData;
- argbPixmapData = 0;
- }
- if (rgbPixmapData) {
- if (rgbPixmapData->gl_surface)
- QGLContextPrivate::destroyGlSurfaceForPixmap(rgbPixmapData);
- delete rgbPixmapData;
- rgbPixmapData = 0;
- }
+ // The pixmap surface destruction hooks are installed by QGLTextureCache, so we
+ // must make sure this is instanciated:
+ QGLTextureCache::instance();
+ } while (0);
if (!haveX11Pixmaps) {
- // Clean up the context(s) if we can't use X11GL pixmaps
- if (qPixmapARGBSharedEglContext != EGL_NO_CONTEXT)
- eglDestroyContext(QEglContext::display(), qPixmapARGBSharedEglContext);
-
- if (qPixmapRGBSharedEglContext != qPixmapARGBSharedEglContext &&
- qPixmapRGBSharedEglContext != EGL_NO_CONTEXT)
- {
- eglDestroyContext(QEglContext::display(), qPixmapRGBSharedEglContext);
+ if (argbContext && (argbContext != rgbContext)) {
+ delete argbContext;
+ argbContext = 0;
+ }
+ if (rgbContext) {
+ delete rgbContext;
+ rgbContext = 0;
}
- qPixmapRGBSharedEglContext = EGL_NO_CONTEXT;
- qPixmapARGBSharedEglContext = EGL_NO_CONTEXT;
}
if (haveX11Pixmaps)
- qDebug("QX11GLPixmapData is supported");
+ qDebug("Using QX11GLPixmapData with EGL config %d for ARGB and config %d for RGB", argbConfigId, rgbConfigId);
else
qDebug("QX11GLPixmapData is *NOT* being used");
@@ -210,11 +197,8 @@ QPaintEngine* QX11GLPixmapData::paintEngine() const
// We need to create the context before beginPaint - do it here:
if (!ctx) {
ctx = new QGLContext(glFormat());
- if (ctx->d_func()->eglContext == 0)
- ctx->d_func()->eglContext = new QEglContext();
- ctx->d_func()->eglContext->setApi(QEgl::OpenGL);
- ctx->d_func()->eglContext->setContext(hasAlphaChannel() ? qPixmapARGBSharedEglContext
- : qPixmapRGBSharedEglContext);
+ Q_ASSERT(ctx->d_func()->eglContext == 0);
+ ctx->d_func()->eglContext = hasAlphaChannel() ? argbContext : rgbContext;
}
QPaintEngine* engine;
@@ -257,10 +241,19 @@ QPaintEngine* QX11GLPixmapData::paintEngine() const
void QX11GLPixmapData::beginPaint()
{
// qDebug("QX11GLPixmapData::beginPaint()");
+ // TODO: Check to see if the surface is renderable
if ((EGLSurface)gl_surface == EGL_NO_SURFACE) {
- qt_createEGLSurfaceForPixmap(this, false);
- ctx->d_func()->eglSurface = (EGLSurface)gl_surface;
- ctx->d_func()->valid = true; // ;-)
+ QPixmap tmpPixmap(this);
+ EGLConfig cfg = ctx->d_func()->eglContext->config();
+
+ EGLSurface surface = QEgl::createSurface(&tmpPixmap, cfg);
+ if (surface == EGL_NO_SURFACE) {
+ qWarning() << "Error creating EGL surface for pixmap:" << QEgl::errorString();
+ return;
+ }
+ gl_surface = (void*)surface;
+ ctx->d_func()->eglSurface = surface;
+ ctx->d_func()->valid = true;
}
QGLPaintDevice::beginPaint();
}
diff --git a/src/opengl/qpixmapdata_x11gl_p.h b/src/opengl/qpixmapdata_x11gl_p.h
index c9f4f56..83cd780 100644
--- a/src/opengl/qpixmapdata_x11gl_p.h
+++ b/src/opengl/qpixmapdata_x11gl_p.h
@@ -59,6 +59,10 @@
#include <qgl.h>
+#ifndef QT_NO_EGL
+#include <QtGui/private/qeglcontext_p.h>
+#endif
+
QT_BEGIN_NAMESPACE
class QX11GLPixmapData : public QX11PixmapData, public QGLPaintDevice
@@ -76,6 +80,11 @@ public:
static bool hasX11GLPixmaps();
static QGLFormat glFormat();
+
+#ifndef QT_NO_EGL
+ static QEglContext* rgbContext;
+ static QEglContext* argbContext;
+#endif
private:
mutable QGLContext* ctx;
};
diff --git a/src/opengl/qwindowsurface_gl.cpp b/src/opengl/qwindowsurface_gl.cpp
index 4ac4a3a..ca88de3 100644
--- a/src/opengl/qwindowsurface_gl.cpp
+++ b/src/opengl/qwindowsurface_gl.cpp
@@ -83,7 +83,7 @@
#endif
#ifdef QT_OPENGL_ES
-#include <private/qegl_p.h>
+#include <private/qeglcontext_p.h>
#endif
QT_BEGIN_NAMESPACE
@@ -353,18 +353,6 @@ void QGLWindowSurface::hijackWindow(QWidget *widget)
QGLContext *ctx = new QGLContext(surfaceFormat, widget);
ctx->create(qt_gl_share_widget()->context());
-#if defined(Q_WS_X11) && defined(QT_OPENGL_ES)
- // Create the EGL surface to draw into. QGLContext::chooseContext()
- // does not do this for X11/EGL, but does do it for other platforms.
- // This probably belongs in qgl_x11egl.cpp.
- QGLContextPrivate *ctxpriv = ctx->d_func();
- ctxpriv->eglSurface = ctxpriv->eglContext->createSurface(widget);
- if (ctxpriv->eglSurface == EGL_NO_SURFACE) {
- qWarning() << "hijackWindow() could not create EGL surface";
- }
- qDebug("QGLWindowSurface - using EGLConfig %d", reinterpret_cast<int>(ctxpriv->eglContext->config()));
-#endif
-
widgetPrivate->extraData()->glContext = ctx;
union { QGLContext **ctxPtr; void **voidPtr; };
generated by cgit v0.12 at 2025-01-22 20:38:48 (GMT)