1 files changed, 47 insertions, 24 deletions

diff --git a/src/plugins/platforms/cocoa/qcocoaglcontext.mm b/src/plugins/platforms/cocoa/qcocoaglcontext.mm
index ba7d12ce30..b312e033cd 100644
--- a/src/plugins/platforms/cocoa/qcocoaglcontext.mm
+++ b/src/plugins/platforms/cocoa/qcocoaglcontext.mm
@@ -223,12 +223,10 @@ NSOpenGLPixelFormat *QCocoaGLContext::pixelFormatForSurfaceFormat(const QSurface
         attrs << NSOpenGLPFAAllowOfflineRenderers;
     }
 
-    // FIXME: Pull this information out of the NSView
-    QByteArray useLayer = qgetenv("QT_MAC_WANTS_LAYER");
-    if (!useLayer.isEmpty() && useLayer.toInt() > 0) {
-        // Disable the software rendering fallback. This makes compositing
-        // OpenGL and raster NSViews using Core Animation layers possible.
-        attrs << NSOpenGLPFANoRecovery;
+    if (qGuiApp->testAttribute(Qt::AA_UseSoftwareOpenGL)) {
+        // kCGLRendererGenericFloatID is the modern software renderer on macOS,
+        // as opposed to kCGLRendererGenericID, which is deprecated.
+        attrs << NSOpenGLPFARendererID << kCGLRendererGenericFloatID;
     }
 
     attrs << 0; // 0-terminate array
@@ -368,23 +366,6 @@ bool QCocoaGLContext::makeCurrent(QPlatformSurface *surface)
     [m_context makeCurrentContext];
 
     if (surface->surface()->surfaceClass() == QSurface::Window) {
-        // Disable high-resolution surfaces when using the software renderer, which has the
-        // problem that the system silently falls back to a to using a low-resolution buffer
-        // when a high-resolution buffer is requested. This is not detectable using the NSWindow
-        // convertSizeToBacking and backingScaleFactor APIs. A typical result of this is that Qt
-        // will display a quarter of the window content when running in a virtual machine.
-        if (!m_didCheckForSoftwareContext) {
-            // FIXME: This ensures we check only once per context,
-            // but the context may be used for multiple surfaces.
-            m_didCheckForSoftwareContext = true;
-
-            const GLubyte* renderer = glGetString(GL_RENDERER);
-            if (qstrcmp((const char *)renderer, "Apple Software Renderer") == 0) {
-                NSView *view = static_cast<QCocoaWindow *>(surface)->m_view;
-                [view setWantsBestResolutionOpenGLSurface:NO];
-            }
-        }
-
         if (m_needsUpdate.fetchAndStoreRelaxed(false))
             update();
     }
@@ -413,11 +394,14 @@ bool QCocoaGLContext::setDrawable(QPlatformSurface *surface)
     }
 
     Q_ASSERT(surface->surface()->surfaceClass() == QSurface::Window);
-    QNSView *view = qnsview_cast(static_cast<QCocoaWindow *>(surface)->view());
+    auto *cocoaWindow = static_cast<QCocoaWindow *>(surface);
+    QNSView *view = qnsview_cast(cocoaWindow->view());
 
     if (view == m_context.view)
         return true;
 
+    prepareDrawable(cocoaWindow);
+
     // Setting the drawable may happen on a separate thread as a result of
     // a call to makeCurrent, so we need to set up the observers before we
     // associate the view with the context. That way we will guarantee that
@@ -460,6 +444,30 @@ bool QCocoaGLContext::setDrawable(QPlatformSurface *surface)
     return true;
 }
 
+void QCocoaGLContext::prepareDrawable(QCocoaWindow *platformWindow)
+{
+    // We generally want high-DPI GL surfaces, unless the user has explicitly disabled them
+    bool prefersBestResolutionOpenGLSurface = qt_mac_resolveOption(YES,
+        platformWindow->window(), "_q_mac_wantsBestResolutionOpenGLSurface",
+        "QT_MAC_WANTS_BEST_RESOLUTION_OPENGL_SURFACE");
+
+    auto *view = platformWindow->view();
+
+    // The only case we have to opt out ourselves is when using the Apple software renderer
+    // in combination with surface-backed views, as these together do not support high-DPI.
+    if (prefersBestResolutionOpenGLSurface) {
+        int rendererID = 0;
+        [m_context getValues:&rendererID forParameter:NSOpenGLContextParameterCurrentRendererID];
+        bool isSoftwareRenderer = (rendererID & kCGLRendererIDMatchingMask) == kCGLRendererGenericFloatID;
+        if (isSoftwareRenderer && !view.layer) {
+            qCInfo(lcQpaOpenGLContext) << "Disabling high resolution GL surface due to software renderer";
+            prefersBestResolutionOpenGLSurface = false;
+        }
+    }
+
+    view.wantsBestResolutionOpenGLSurface = prefersBestResolutionOpenGLSurface;
+}
+
 // NSOpenGLContext is not re-entrant. Even when using separate contexts per thread,
 // view, and window, calls into the API will still deadlock. For more information
 // see https://openradar.appspot.com/37064579
@@ -491,6 +499,21 @@ void QCocoaGLContext::swapBuffers(QPlatformSurface *surface)
         return;
     }
 
+    if (m_context.view.layer) {
+        // Flushing an NSOpenGLContext will hit the screen immediately, ignoring
+        // any Core Animation transactions in place. This may result in major
+        // visual artifacts if the flush happens out of sync with the size
+        // of the layer, view, and window reflected by other parts of the UI,
+        // e.g. if the application flushes in the resize event or a timer during
+        // window resizing, instead of in the expose event.
+        auto *cocoaWindow = static_cast<QCocoaWindow *>(surface);
+        if (cocoaWindow->geometry().size() != cocoaWindow->m_exposedRect.size()) {
+            qCInfo(lcQpaOpenGLContext) << "Window exposed size does not match geometry (yet)."
+                << "Skipping flush to avoid visual artifacts.";
+            return;
+        }
+    }
+
     QMutexLocker locker(&s_reentrancyMutex);
     [m_context flushBuffer];
 }