1 files changed, 108 insertions, 50 deletions
diff --git a/src/plugins/platforms/wasm/qwasmopenglcontext.cpp b/src/plugins/platforms/wasm/qwasmopenglcontext.cpp
index da9219bd6e..8a4664ec8c 100644
--- a/src/plugins/platforms/wasm/qwasmopenglcontext.cpp
+++ b/src/plugins/platforms/wasm/qwasmopenglcontext.cpp
@@ -2,38 +2,43 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
 #include "qwasmopenglcontext.h"
+
+#include "qwasmoffscreensurface.h"
 #include "qwasmintegration.h"
 #include <EGL/egl.h>
+#include <emscripten/bind.h>
 #include <emscripten/val.h>
 
+namespace {
+void qtDoNothing(emscripten::val) { }
+} // namespace
+
+EMSCRIPTEN_BINDINGS(qwasmopenglcontext)
+{
+    function("qtDoNothing", &qtDoNothing);
+}
+
 QT_BEGIN_NAMESPACE
 
-QWasmOpenGLContext::QWasmOpenGLContext(const QSurfaceFormat &format)
-    : m_requestedFormat(format)
+QWasmOpenGLContext::QWasmOpenGLContext(QOpenGLContext *context)
+    : m_actualFormat(context->format()), m_qGlContext(context)
 {
-    m_requestedFormat.setRenderableType(QSurfaceFormat::OpenGLES);
+    m_actualFormat.setRenderableType(QSurfaceFormat::OpenGLES);
 
     // if we set one, we need to set the other as well since in webgl, these are tied together
-    if (format.depthBufferSize() < 0 && format.stencilBufferSize() > 0)
-       m_requestedFormat.setDepthBufferSize(16);
-
-   if (format.stencilBufferSize() < 0 && format.depthBufferSize() > 0)
-       m_requestedFormat.setStencilBufferSize(8);
+    if (m_actualFormat.depthBufferSize() < 0 && m_actualFormat.stencilBufferSize() > 0)
+        m_actualFormat.setDepthBufferSize(16);
 
+    if (m_actualFormat.stencilBufferSize() < 0 && m_actualFormat.depthBufferSize() > 0)
+        m_actualFormat.setStencilBufferSize(8);
 }
 
 QWasmOpenGLContext::~QWasmOpenGLContext()
 {
-    if (m_context) {
-        // Destroy GL context. Work around bug in emscripten_webgl_destroy_context
-        // which removes all event handlers on the canvas by temporarily removing
-        // emscripten's JSEvents global object.
-        emscripten::val jsEvents = emscripten::val::global("window")["JSEvents"];
-        emscripten::val::global("window").set("JSEvents", emscripten::val::undefined());
-        emscripten_webgl_destroy_context(m_context);
-        emscripten::val::global("window").set("JSEvents", jsEvents);
-        m_context = 0;
-    }
+    // Destroy GL context. Work around bug in emscripten_webgl_destroy_context
+    // which removes all event handlers on the canvas by temporarily replacing the function
+    // that does the removal with a function that does nothing.
+    destroyWebGLContext(m_ownedWebGLContext.handle);
 }
 
 bool QWasmOpenGLContext::isOpenGLVersionSupported(QSurfaceFormat format)
@@ -46,27 +51,66 @@ bool QWasmOpenGLContext::isOpenGLVersionSupported(QSurfaceFormat format)
            (format.majorVersion() == 3 && format.minorVersion() == 0));
 }
 
-bool QWasmOpenGLContext::maybeCreateEmscriptenContext(QPlatformSurface *surface)
+EMSCRIPTEN_WEBGL_CONTEXT_HANDLE
+QWasmOpenGLContext::obtainEmscriptenContext(QPlatformSurface *surface)
 {
-    // Native emscripten/WebGL contexts are tied to a single screen/canvas. The first
-    // call to this function creates a native canvas for the given screen, subsequent
-    // calls verify that the surface is on/off the same screen.
-    QPlatformScreen *screen = surface->screen();
-    if (m_context && !screen)
-        return false; // Alternative: return true to support makeCurrent on QOffScreenSurface with
-                      // no screen. However, Qt likes to substitute QGuiApplication::primaryScreen()
-                      // for null screens, which foils this plan.
-    if (!screen)
-        return false;
-    if (m_context)
-        return m_screen == screen;
+    if (m_ownedWebGLContext.surface == surface)
+        return m_ownedWebGLContext.handle;
+
+    if (surface->surface()->surfaceClass() == QSurface::Offscreen) {
+        // Reuse the existing context for offscreen drawing, even if it happens to be a canvas
+        // context. This is because it is impossible to re-home an existing context to the
+        // new surface and works as an emulation measure.
+        if (m_ownedWebGLContext.handle)
+            return m_ownedWebGLContext.handle;
+
+        //  The non-shared offscreen context is heavily limited on WASM, but we provide it
+        //  anyway for potential pixel readbacks.
+        m_ownedWebGLContext =
+                QOpenGLContextData{ .surface = surface,
+                                    .handle = createEmscriptenContext(
+                                            static_cast<QWasmOffscreenSurface *>(surface)->id(),
+                                            m_actualFormat) };
+    } else {
+        destroyWebGLContext(m_ownedWebGLContext.handle);
+
+        // Create a full on-screen context for the window canvas.
+        m_ownedWebGLContext = QOpenGLContextData{
+            .surface = surface,
+            .handle = createEmscriptenContext(static_cast<QWasmWindow *>(surface)->canvasSelector(),
+                                              m_actualFormat)
+        };
+    }
+
+    EmscriptenWebGLContextAttributes actualAttributes;
+
+    EMSCRIPTEN_RESULT attributesResult = emscripten_webgl_get_context_attributes(m_ownedWebGLContext.handle, &actualAttributes);
+    if (attributesResult == EMSCRIPTEN_RESULT_SUCCESS) {
+        if (actualAttributes.majorVersion == 1) {
+            m_actualFormat.setMajorVersion(2);
+        } else if (actualAttributes.majorVersion == 2) {
+            m_actualFormat.setMajorVersion(3);
+        }
+        m_actualFormat.setMinorVersion(0);
+    }
+
+    return m_ownedWebGLContext.handle;
+}
 
-    m_context = createEmscriptenContext(QWasmScreen::get(screen)->canvasTargetId(), m_requestedFormat);
-    m_screen = screen;
-    return true;
+void QWasmOpenGLContext::destroyWebGLContext(EMSCRIPTEN_WEBGL_CONTEXT_HANDLE contextHandle)
+{
+    if (!contextHandle)
+        return;
+    emscripten::val jsEvents = emscripten::val::module_property("JSEvents");
+    emscripten::val savedRemoveAllHandlersOnTargetFunction = jsEvents["removeAllHandlersOnTarget"];
+    jsEvents.set("removeAllHandlersOnTarget", emscripten::val::module_property("qtDoNothing"));
+    emscripten_webgl_destroy_context(contextHandle);
+    jsEvents.set("removeAllHandlersOnTarget", savedRemoveAllHandlersOnTargetFunction);
 }
 
-EMSCRIPTEN_WEBGL_CONTEXT_HANDLE QWasmOpenGLContext::createEmscriptenContext(const QString &canvasTargetId, QSurfaceFormat format)
+EMSCRIPTEN_WEBGL_CONTEXT_HANDLE
+QWasmOpenGLContext::createEmscriptenContext(const std::string &canvasSelector,
+                                            QSurfaceFormat format)
 {
     EmscriptenWebGLContextAttributes attributes;
     emscripten_webgl_init_context_attributes(&attributes); // Populate with default attributes
@@ -75,27 +119,30 @@ EMSCRIPTEN_WEBGL_CONTEXT_HANDLE QWasmOpenGLContext::createEmscriptenContext(cons
     attributes.failIfMajorPerformanceCaveat = false;
     attributes.antialias = true;
     attributes.enableExtensionsByDefault = true;
-    attributes.majorVersion = format.majorVersion() - 1;
-    attributes.minorVersion = format.minorVersion();
-
+    attributes.majorVersion = 2; // try highest supported version ES3.0 / WebGL 2.0
+    attributes.minorVersion = 0; // emscripten only supports minor version 0
     // WebGL doesn't allow separate attach buffers to STENCIL_ATTACHMENT and DEPTH_ATTACHMENT
     // we need both or none
-    bool useDepthStencil = (format.depthBufferSize() > 0 || format.stencilBufferSize() > 0);
+    const bool useDepthStencil = (format.depthBufferSize() > 0 || format.stencilBufferSize() > 0);
 
     // WebGL offers enable/disable control but not size control for these
     attributes.alpha = format.alphaBufferSize() > 0;
     attributes.depth = useDepthStencil;
     attributes.stencil = useDepthStencil;
+    EMSCRIPTEN_RESULT contextResult = emscripten_webgl_create_context(canvasSelector.c_str(), &attributes);
 
-    QByteArray convasSelector = canvasTargetId.toUtf8();
-    EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context(convasSelector.constData(), &attributes);
-
-    return context;
+    if (contextResult <= 0) {
+        // fallback to opengles2/webgl1
+        // for devices that do not support opengles3/webgl2
+        attributes.majorVersion = 1;
+        contextResult = emscripten_webgl_create_context(canvasSelector.c_str(), &attributes);
+    }
+    return contextResult;
 }
 
 QSurfaceFormat QWasmOpenGLContext::format() const
 {
-    return m_requestedFormat;
+    return m_actualFormat;
 }
 
 GLuint QWasmOpenGLContext::defaultFramebufferObject(QPlatformSurface *surface) const
@@ -105,11 +152,22 @@ GLuint QWasmOpenGLContext::defaultFramebufferObject(QPlatformSurface *surface) c
 
 bool QWasmOpenGLContext::makeCurrent(QPlatformSurface *surface)
 {
-    bool ok = maybeCreateEmscriptenContext(surface);
-    if (!ok)
+    static bool sentSharingWarning = false;
+    if (!sentSharingWarning && isSharing()) {
+        qWarning() << "The functionality for sharing OpenGL contexts is limited, see documentation";
+        sentSharingWarning = true;
+    }
+
+    if (auto *shareContext = m_qGlContext->shareContext())
+        return shareContext->makeCurrent(surface->surface());
+
+    const auto context = obtainEmscriptenContext(surface);
+    if (!context)
         return false;
 
-    return emscripten_webgl_make_context_current(m_context) == EMSCRIPTEN_RESULT_SUCCESS;
+    m_usedWebGLContextHandle = context;
+
+    return emscripten_webgl_make_context_current(context) == EMSCRIPTEN_RESULT_SUCCESS;
 }
 
 void QWasmOpenGLContext::swapBuffers(QPlatformSurface *surface)
@@ -125,17 +183,17 @@ void QWasmOpenGLContext::doneCurrent()
 
 bool QWasmOpenGLContext::isSharing() const
 {
-    return false;
+    return m_qGlContext->shareContext();
 }
 
 bool QWasmOpenGLContext::isValid() const
 {
-    if (!(isOpenGLVersionSupported(m_requestedFormat)))
+    if (!isOpenGLVersionSupported(m_actualFormat))
         return false;
 
     // Note: we get isValid() calls before we see the surface and can
     // create a native context, so no context is also a valid state.
-    return !m_context || !emscripten_is_webgl_context_lost(m_context);
+    return !m_usedWebGLContextHandle || !emscripten_is_webgl_context_lost(m_usedWebGLContextHandle);
 }
 
 QFunctionPointer QWasmOpenGLContext::getProcAddress(const char *procName)