AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Windows platform: Improve Open GL.

Browse Source 
- Pass on version to ARB.
- Query obtained ARB format more fine-grained depending on version,
  indicate failures
- Fix GDI contexts and introduce gl=gdi to activate the GDI
  functionality
- Adapt window flags after setParent if top level state changes
- Remove unused OpenGL flag from integration/context

Change-Id: I59ca74ee1fa727bd2bcfd605b3907bc82cca18fa
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
This commit is contained in:
Friedemann Kleint 2011-10-18 15:33:19 +02:00 committed by Qt by Nokia
parent 87274e272d
commit b419e567c0
9 changed files with 155 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/plugins/platforms/windows/main.cpp
View File

@ -53,6 +53,17 @@ QT_BEGIN_NAMESPACE
\brief Class documentation of the Qt Lighthouse plugin for Windows.
\section1 Supported parameters
The following parameters can be passed on to the -platform argument
of QGuiApplication:
\list
\o \c fontengine=native Indicates that the freetype font
engine should not be used.
\o \c gl=gdi Indicates that ARB Open GL functionality should not be used
\endlist
\section1 Tips
\list

20
src/plugins/platforms/windows/qwindowscontext.cpp
View File

@ -193,9 +193,8 @@ QWindowsContext *QWindowsContext::m_instance = 0;
typedef QHash<HWND, QWindowsWindow *> HandleBaseWindowHash;
struct QWindowsContextPrivate {
explicit QWindowsContextPrivate(bool isOpenGL);
QWindowsContextPrivate();
const bool m_isOpenGL;
unsigned m_systemInfo;
QSet<QString> m_registeredWindowClassNames;
HandleBaseWindowHash m_windows;
@ -208,8 +207,7 @@ struct QWindowsContextPrivate {
const HRESULT m_oleInitializeResult;
};
QWindowsContextPrivate::QWindowsContextPrivate(bool isOpenGL) :
m_isOpenGL(isOpenGL),
QWindowsContextPrivate::QWindowsContextPrivate() :
m_systemInfo(0),
m_displayContext(GetDC(0)),
m_defaultDPI(GetDeviceCaps(m_displayContext,LOGPIXELSY)),
@ -228,8 +226,8 @@ QWindowsContextPrivate::QWindowsContextPrivate(bool isOpenGL) :
}
}
QWindowsContext::QWindowsContext(bool isOpenGL) :
d(new QWindowsContextPrivate(isOpenGL))
QWindowsContext::QWindowsContext() :
d(new QWindowsContextPrivate)
{
#ifdef Q_CC_MSVC
# pragma warning( disable : 4996 )
@ -271,11 +269,6 @@ void QWindowsContext::setWindowCreationContext(const QSharedPointer<QWindowCreat
d->m_creationContext = ctx;
}
bool QWindowsContext::isOpenGL() const
{
return d->m_isOpenGL;
}
int QWindowsContext::defaultDPI() const
{
return d->m_defaultDPI;
@ -345,11 +338,6 @@ QString QWindowsContext::registerWindowClass(const QWindow *w, bool isGL)
icon = true;
}
// force CS_OWNDC when the GL graphics system is
// used as the default renderer
if (d->m_isOpenGL)
style |= CS_OWNDC;
HBRUSH brush = 0;
if (w && !isGL)
brush = GetSysColorBrush(COLOR_WINDOW);

4
src/plugins/platforms/windows/qwindowscontext.h
View File

@ -108,11 +108,9 @@ public:
static int verboseOLE;
static int verboseInputMethods;
explicit QWindowsContext(bool isOpenGL);
explicit QWindowsContext();
~QWindowsContext();
bool isOpenGL() const;
int defaultDPI() const;
QString registerWindowClass(const QWindow *w, bool isGL);

2
src/plugins/platforms/windows/qwindowscursor.cpp
View File

@ -353,7 +353,7 @@ QWindowsWindowCursor QWindowsCursor::standardWindowCursor(Qt::CursorShape shape)
void QWindowsCursor::changeCursor(QCursor *cursorIn, QWindow *window)
{
if (QWindowsContext::verboseWindows)
if (QWindowsContext::verboseWindows > 1)
qDebug() << __FUNCTION__ << cursorIn << window;
if (!cursorIn || !window)
return;

112
src/plugins/platforms/windows/qwindowsglcontext.cpp
View File

@ -45,6 +45,8 @@
#include <QtCore/QDebug>
#include <QtCore/QSysInfo>
#include <QtGui/QGuiApplication>
#include <QtGui/QPlatformNativeInterface>
#include <WinGDI.h>
#include <GL/Gl.h>
@ -511,14 +513,15 @@ static QSurfaceFormat
iAttributes[i++] = WGL_STEREO_ARB; // 9
iAttributes[i++] = WGL_ACCELERATION_ARB; // 10
iAttributes[i++] = WGL_NUMBER_OVERLAYS_ARB; // 11
iAttributes[i++] = WGL_CONTEXT_FLAGS_ARB; // 12
if (hasSampleBuffers) {
iAttributes[i++] = WGL_SAMPLE_BUFFERS_ARB; // 13
iAttributes[i++] = WGL_SAMPLES_ARB; // 14
iAttributes[i++] = WGL_SAMPLE_BUFFERS_ARB; // 12
iAttributes[i++] = WGL_SAMPLES_ARB; // 13
}
if (!staticContext.wglGetPixelFormatAttribIVARB(hdc, pixelFormat, 0, i,
iAttributes, iValues))
iAttributes, iValues)) {
qErrnoWarning("%s: wglGetPixelFormatAttribIVARB() failed for basic parameters.", __FUNCTION__);
return result;
}
if (iValues[0])
result.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
result.setDepthBufferSize(iValues[1]);
@ -529,12 +532,9 @@ static QSurfaceFormat
result.setStencilBufferSize(iValues[8]);
if (iValues[9])
result.setOption(QSurfaceFormat::StereoBuffers);
if (iValues[12] & WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB)
result.setOption(QSurfaceFormat::DeprecatedFunctions);
if (iValues[12] & WGL_CONTEXT_DEBUG_BIT_ARB)
result.setOption(QSurfaceFormat::DebugContext);
if (hasSampleBuffers)
result.setSamples(iValues[14]);
result.setSamples(iValues[13]);
if (additionalIn) {
if (iValues[7])
additionalIn->formatFlags |= QWindowsGLAccumBuffer;
@ -543,6 +543,49 @@ static QSurfaceFormat
if (iValues[11])
additionalIn->formatFlags |= QWindowsGLOverlay;
}
// Check version. Known to fail for some drivers
if (staticContext.majorVersion > 1) {
i = 0;
iAttributes[i++] = WGL_CONTEXT_MAJOR_VERSION_ARB; // 0
iAttributes[i++] = WGL_CONTEXT_MINOR_VERSION_ARB; // 1
if (staticContext.wglGetPixelFormatAttribIVARB(hdc, pixelFormat, 0, i,
iAttributes, iValues)) {
result.setMajorVersion(iValues[0]);
result.setMinorVersion(iValues[1]);
} else {
qErrnoWarning("%s: wglGetPixelFormatAttribIVARB() failed for version.", __FUNCTION__);
}
}
// Query flags from 3.2 onwards
if (staticContext.majorVersion > 3) {
i = 0;
iAttributes[i++] = WGL_CONTEXT_FLAGS_ARB; // 0
if (staticContext.wglGetPixelFormatAttribIVARB(hdc, pixelFormat, 0, i,
iAttributes, iValues)) {
if (iValues[0] & WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB)
result.setOption(QSurfaceFormat::DeprecatedFunctions);
if (iValues[0] & WGL_CONTEXT_DEBUG_BIT_ARB)
result.setOption(QSurfaceFormat::DebugContext);
} else {
qErrnoWarning("%s: wglGetPixelFormatAttribIVARB() failed for context flags.", __FUNCTION__);
}
}
// Query profile from 3.2 onwards. Known to fail for some drivers
if ((staticContext.majorVersion == 3 && staticContext.minorVersion >= 2)
|| staticContext.majorVersion > 3) {
i = 0;
iAttributes[i++] = WGL_CONTEXT_PROFILE_MASK_ARB; // 0
if (staticContext.wglGetPixelFormatAttribIVARB(hdc, pixelFormat, 0, i,
iAttributes, iValues)) {
if (iValues[0] & WGL_CONTEXT_CORE_PROFILE_BIT_ARB) {
result.setProfile(QSurfaceFormat::CoreProfile);
} else if (iValues[0] & WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB) {
result.setProfile(QSurfaceFormat::CompatibilityProfile);
}
} else {
qErrnoWarning("%s: wglGetPixelFormatAttribIVARB() failed for profile mask.", __FUNCTION__);
}
}
return result;
}
@ -550,8 +593,6 @@ static HGLRC createContext(const QOpenGLStaticContext &staticContext,
HDC hdc,
const QSurfaceFormat &format,
const QWindowsOpenGLAdditionalFormat &,
int majorVersion = 0,
int minorVersion = 0,
HGLRC shared = 0)
{
enum { attribSize = 11 };
@ -562,7 +603,15 @@ static HGLRC createContext(const QOpenGLStaticContext &staticContext,
int attribIndex = 0;
qFill(attributes, attributes + attribSize, int(0));
if (majorVersion) {
const int formatMajorVersion = format.majorVersion();
const int formatMinorVersion = format.minorVersion();
const bool versionRequested = formatMajorVersion != 1 || formatMinorVersion != 1;
const int majorVersion = versionRequested ?
formatMajorVersion : staticContext.majorVersion;
const int minorVersion = versionRequested ?
formatMinorVersion : staticContext.minorVersion;
if (majorVersion > 1) {
attributes[attribIndex++] = WGL_CONTEXT_MAJOR_VERSION_ARB;
attributes[attribIndex++] = majorVersion;
attributes[attribIndex++] = WGL_CONTEXT_MINOR_VERSION_ARB;
@ -577,8 +626,8 @@ static HGLRC createContext(const QOpenGLStaticContext &staticContext,
attributes[attribIndex++] |= WGL_CONTEXT_DEBUG_BIT_ARB;
attribIndex++;
}
if ((staticContext.majorVersion == 3 && staticContext.minorVersion >= 2)
|| staticContext.majorVersion > 3) {
if ((majorVersion == 3 && minorVersion >= 2)
|| majorVersion > 3) {
switch (format.profile()) {
case QSurfaceFormat::NoProfile:
break;
@ -592,6 +641,10 @@ static HGLRC createContext(const QOpenGLStaticContext &staticContext,
break;
}
}
if (QWindowsContext::verboseGL)
qDebug("%s: Creating context version %d.%d with %d attributes",
__FUNCTION__, majorVersion, minorVersion, attribIndex / 2);
const HGLRC result =
staticContext.wglCreateContextAttribsARB(hdc, shared, attributes);
if (!result)
@ -770,6 +823,16 @@ QDebug operator<<(QDebug d, const QOpenGLStaticContext &s)
return d;
}
// Use ARB unless explicitly turned off on command line.
static inline bool useARB()
{
const QVariant glExtension = qApp->platformNativeInterface()->property("gl");
if (glExtension.type() == QVariant::String
&& !glExtension.toString().compare(QStringLiteral("gdi"), Qt::CaseInsensitive))
return false;
return true;
}
/*!
\class QWindowsGLContext
\brief Open GL context.
@ -788,6 +851,7 @@ QWindowsGLContext::QWindowsGLContext(const QOpenGLStaticContextPtr &staticContex
QOpenGLContext *context) :
m_staticContext(staticContext),
m_context(context),
m_renderingContext(0),
m_pixelFormat(0), m_extensionsUsed(false)
{
// workaround for matrox driver:
@ -805,6 +869,7 @@ QWindowsGLContext::QWindowsGLContext(const QOpenGLStaticContextPtr &staticContex
// (default to GDI) and store that.
HWND dummyWindow = 0;
HDC hdc = 0;
bool tryExtensions = false;
do {
dummyWindow = createDummyGLWindow();
if (!dummyWindow)
@ -818,8 +883,9 @@ QWindowsGLContext::QWindowsGLContext(const QOpenGLStaticContextPtr &staticContex
// Preferably use direct rendering and ARB extensions (unless pixmap)
const QWindowsOpenGLAdditionalFormat
requestedAdditional(QWindowsGLDirectRendering);
const bool tryExtensions = m_staticContext->hasExtensions()
&& !testFlag(requestedAdditional.formatFlags, QWindowsGLRenderToPixmap);
tryExtensions = m_staticContext->hasExtensions()
&& !testFlag(requestedAdditional.formatFlags, QWindowsGLRenderToPixmap)
&& useARB();
QWindowsOpenGLAdditionalFormat obtainedAdditional;
if (tryExtensions) {
m_pixelFormat =
@ -855,8 +921,10 @@ QWindowsGLContext::QWindowsGLContext(const QOpenGLStaticContextPtr &staticContex
if (m_extensionsUsed)
m_renderingContext =
ARB::createContext(*m_staticContext, hdc, context->format(),
requestedAdditional, 0, 0, sharingRenderingContext);
ARB::createContext(*m_staticContext, hdc,
context->format(),
requestedAdditional,
sharingRenderingContext);
if (!m_renderingContext)
m_renderingContext = GDI::createContext(hdc, sharingRenderingContext);
@ -871,8 +939,8 @@ QWindowsGLContext::QWindowsGLContext(const QOpenGLStaticContextPtr &staticContex
DestroyWindow(dummyWindow);
if (QWindowsContext::verboseGL)
qDebug()
<< __FUNCTION__ << this << " requested: " << context->format()
qDebug() << __FUNCTION__ << this << (tryExtensions ? "ARB" : "GDI")
<< " requested: " << context->format()
<< "\n obtained #" << m_pixelFormat << (m_extensionsUsed ? "ARB" : "GDI")
<< m_obtainedFormat << "\n " << m_obtainedPixelFormatDescriptor
<< "\n HGLRC=" << m_renderingContext;
@ -968,10 +1036,12 @@ QWindowsGLContext::GL_Proc QWindowsGLContext::getProcAddress(const QByteArray &p
{
// TODO: Will that work with the calling conventions?
GL_Proc procAddress = reinterpret_cast<GL_Proc>(wglGetProcAddress(procName.constData()));
if (QWindowsContext::verboseGL)
if (QWindowsContext::verboseGL > 1)
qDebug("%s('%s') with current_hglrc=%p returns %p",
__FUNCTION__, procName.constData(),
wglGetCurrentContext(), procAddress);
if (!procAddress)
qWarning("%s: Unable to resolve '%s'", __FUNCTION__, procName.constData());
return procAddress;
}

16
src/plugins/platforms/windows/qwindowsintegration.cpp
View File

@ -146,10 +146,9 @@ struct QWindowsIntegrationPrivate
{
typedef QSharedPointer<QOpenGLStaticContext> QOpenGLStaticContextPtr;
explicit QWindowsIntegrationPrivate(bool openGL);
QWindowsIntegrationPrivate();
~QWindowsIntegrationPrivate();
const bool m_openGL;
QWindowsContext m_context;
QPlatformFontDatabase *m_fontDatabase;
QWindowsNativeInterface m_nativeInterface;
@ -161,10 +160,8 @@ struct QWindowsIntegrationPrivate
QWindowsAccessibility m_accessibility;
};
QWindowsIntegrationPrivate::QWindowsIntegrationPrivate(bool openGL)
: m_openGL(openGL)
, m_context(openGL)
, m_eventDispatcher(new QWindowsGuiEventDispatcher)
QWindowsIntegrationPrivate::QWindowsIntegrationPrivate()
: m_eventDispatcher(new QWindowsGuiEventDispatcher)
, m_fontDatabase(0)
{
}
@ -175,8 +172,8 @@ QWindowsIntegrationPrivate::~QWindowsIntegrationPrivate()
delete m_fontDatabase;
}
QWindowsIntegration::QWindowsIntegration(bool openGL) :
d(new QWindowsIntegrationPrivate(openGL))
QWindowsIntegration::QWindowsIntegration() :
d(new QWindowsIntegrationPrivate)
{
QGuiApplicationPrivate::instance()->setEventDispatcher(d->m_eventDispatcher);
d->m_clipboard.registerViewer();
@ -214,12 +211,11 @@ QPlatformPixmap *QWindowsIntegration::createPlatformPixmap(QPlatformPixmap::Pixe
QPlatformWindow *QWindowsIntegration::createPlatformWindow(QWindow *window) const
{
const bool isGL = window->surfaceType() == QWindow::OpenGLSurface;
QWindowsWindow::WindowData requested;
requested.flags = window->windowFlags();
requested.geometry = window->geometry();
const QWindowsWindow::WindowData obtained
= QWindowsWindow::WindowData::create(window, requested, window->windowTitle(), isGL);
= QWindowsWindow::WindowData::create(window, requested, window->windowTitle());
if (QWindowsContext::verboseIntegration || QWindowsContext::verboseWindows)
qDebug().nospace()
<< __FUNCTION__ << ' ' << window << '\n'

2
src/plugins/platforms/windows/qwindowsintegration.h
View File

@ -52,7 +52,7 @@ struct QWindowsIntegrationPrivate;
class QWindowsIntegration : public QPlatformIntegration
{
public:
QWindowsIntegration(bool openGL = false);
QWindowsIntegration();
virtual ~QWindowsIntegration();
bool hasCapability(QPlatformIntegration::Capability cap) const;

54
src/plugins/platforms/windows/qwindowswindow.cpp
View File

@ -57,7 +57,6 @@ QT_BEGIN_NAMESPACE
static QByteArray debugWinStyle(DWORD style)
{
QByteArray rc = "0x";
rc += QByteArray::number(qulonglong(style), 16);
if (style & WS_POPUP)
@ -83,6 +82,19 @@ static QByteArray debugWinStyle(DWORD style)
return rc;
}
static QByteArray debugWinExStyle(DWORD exStyle)
{
QByteArray rc = "0x";
rc += QByteArray::number(qulonglong(exStyle), 16);
if (exStyle & WS_EX_TOOLWINDOW)
rc += " WS_EX_TOOLWINDOW";
if (exStyle & WS_EX_CONTEXTHELP)
rc += " WS_EX_CONTEXTHELP";
if (exStyle & WS_EX_LAYERED)
rc += " WS_EX_LAYERED";
return rc;
}
static QByteArray debugWindowStates(Qt::WindowStates s)
{
@ -194,12 +206,13 @@ static bool shouldShowMaximizeButton(Qt::WindowFlags flags)
struct WindowCreationData
{
typedef QWindowsWindow::WindowData WindowData;
enum Flags { ForceChild = 0x1 };
WindowCreationData() : parentHandle(0), type(Qt::Widget), style(0), exStyle(0),
topLevel(false), popup(false), dialog(false), desktop(false),
tool(false) {}
void fromWindow(const QWindow *w, const Qt::WindowFlags flags, bool isGL);
void fromWindow(const QWindow *w, const Qt::WindowFlags flags, unsigned creationFlags = 0);
inline WindowData create(const QWindow *w, const QRect &geometry, QString title) const;
inline void applyWindowFlags(HWND hwnd) const;
void initialize(HWND h, bool frameChange) const;
@ -220,20 +233,20 @@ struct WindowCreationData
QDebug operator<<(QDebug debug, const WindowCreationData &d)
{
debug.nospace() << QWindowsWindow::debugWindowFlags(d.flags)
<< " gs=" << d.isGL << " topLevel=" << d.topLevel << " popup="
<< " GL=" << d.isGL << " topLevel=" << d.topLevel << " popup="
<< d.popup << " dialog=" << d.dialog << " desktop=" << d.desktop
<< " tool=" << d.tool << " style=" << debugWinStyle(d.style)
<< " exStyle=0x" << QString::number(d.exStyle, 16)
<< " exStyle=" << debugWinExStyle(d.exStyle)
<< " parent=" << d.parentHandle;
return debug;
}
void WindowCreationData::fromWindow(const QWindow *w, const Qt::WindowFlags flagsIn,
bool isGLin)
unsigned creationFlags)
{
isGL = isGLin;
isGL = w->surfaceType() == QWindow::OpenGLSurface;
flags = flagsIn;
topLevel = w->isTopLevel();
topLevel = (creationFlags & ForceChild) ? false : w->isTopLevel();
if (topLevel && flags == 1) {
qWarning("Remove me: fixing toplevel window flags");
@ -397,9 +410,9 @@ void WindowCreationData::applyWindowFlags(HWND hwnd) const
if (QWindowsContext::verboseWindows)
qDebug().nospace() << __FUNCTION__ << hwnd << *this
<< "\n Style from " << debugWinStyle(oldStyle) << "\n to "
<< debugWinStyle(newStyle) << "\n ExStyle from 0x"
<< QByteArray::number(qulonglong(oldExStyle), 16) << " to 0x"
<< QByteArray::number(qulonglong(newExStyle), 16);
<< debugWinStyle(newStyle) << "\n ExStyle from "
<< debugWinExStyle(oldExStyle) << " to "
<< debugWinExStyle(newExStyle);
}
void WindowCreationData::initialize(HWND hwnd, bool frameChange) const
@ -651,12 +664,11 @@ QWindow *QWindowsWindow::topLevelOf(QWindow *w)
QWindowsWindow::WindowData
QWindowsWindow::WindowData::create(const QWindow *w,
const WindowData &parameters,
const QString &title,
bool isGL)
const WindowData &parameters,
const QString &title)
{
WindowCreationData creationData;
creationData.fromWindow(w, parameters.flags, isGL);
creationData.fromWindow(w, parameters.flags);
WindowData result = creationData.create(w, parameters.geometry, title);
creationData.initialize(result.hwnd, false);
return result;
@ -748,8 +760,17 @@ void QWindowsWindow::setParent_sys(const QPlatformWindow *parent) const
if (parent) {
const QWindowsWindow *parentW = static_cast<const QWindowsWindow *>(parent);
parentHWND = parentW->handle();
}
const bool wasTopLevel = window()->isTopLevel();
const bool isTopLevel = parentHWND == 0;
SetParent(m_data.hwnd, parentHWND);
// WS_CHILD/WS_POPUP must be manually set/cleared in addition
// to dialog frames, etc (see SetParent() ) if the top level state changes.
if (wasTopLevel != isTopLevel) {
const unsigned flags = isTopLevel ? unsigned(0) : unsigned(WindowCreationData::ForceChild);
setWindowFlags_sys(window()->windowFlags(), flags);
}
}
void QWindowsWindow::handleShown()
@ -934,11 +955,12 @@ Qt::WindowFlags QWindowsWindow::setWindowFlags(Qt::WindowFlags flags)
return m_data.flags;
}
QWindowsWindow::WindowData QWindowsWindow::setWindowFlags_sys(Qt::WindowFlags wt) const
QWindowsWindow::WindowData QWindowsWindow::setWindowFlags_sys(Qt::WindowFlags wt,
unsigned flags) const
{
// Geometry changes have not been observed here. Frames change, though.
WindowCreationData creationData;
creationData.fromWindow(window(), wt, window()->surfaceType() == QWindow::OpenGLSurface);
creationData.fromWindow(window(), wt, flags);
creationData.applyWindowFlags(m_data.hwnd);
creationData.initialize(m_data.hwnd, true);
WindowData result = m_data;

5
src/plugins/platforms/windows/qwindowswindow.h
View File

@ -112,8 +112,7 @@ public:
static WindowData create(const QWindow *w,
const WindowData &parameters,
const QString &title,
bool isGL);
const QString &title);
};
QWindowsWindow(QWindow *window, const WindowData &data);
@ -193,7 +192,7 @@ private:
inline void hide_sys() const;
inline void setGeometry_sys(const QRect &rect) const;
inline QRect geometry_sys() const;
inline WindowData setWindowFlags_sys(Qt::WindowFlags wt) const;
inline WindowData setWindowFlags_sys(Qt::WindowFlags wt, unsigned flags = 0) const;
inline void setWindowState_sys(Qt::WindowState newState);
inline void setParent_sys(const QPlatformWindow *parent) const;
inline void setOpacity_sys(qreal level) const;