Initial support for OpenGL ES 3.0 (GLES3)

rodlie · rodlie · commit c2c00605e408 · 2026-06-21T05:41:34.000+02:00
diff --git a/src/app/GUI/Settings/pluginssettingswidget.cpp b/src/app/GUI/Settings/pluginssettingswidget.cpp
@@ -41,6 +41,10 @@ PluginsSettingsWidget::PluginsSettingsWidget(QWidget *parent)
     , mShaderPath(nullptr)
     , mShaderTree(nullptr)
 {
+#ifdef USE_GLES
+    const auto label = new QLabel(tr("Shaders not supported when using OpenGL ES 3.0."), this);
+    addWidget(label);
+#else
     mShadersList = EffectsLoader::sInstance->getLoadedShaderEffects();
 
     mShadersDisabled = AppSupport::getSettings("settings",
@@ -93,10 +97,12 @@ PluginsSettingsWidget::PluginsSettingsWidget(QWidget *parent)
                        .arg(tr("Any changes in this section require a restart of Friction"),
                             tr("Also note that shader effects are still considered experimental")));
     addWidget(infoLabel);
+#endif
 }
 
 void PluginsSettingsWidget::applySettings()
 {
+#ifndef USE_GLES
     AppSupport::setSettings("settings",
                             "CustomShaderPath",
                             mShaderPath->text());
@@ -109,21 +115,27 @@ void PluginsSettingsWidget::applySettings()
     AppSupport::setSettings("settings",
                             "DisabledShaders",
                             disabledShaders);
+#endif
 }
 
 void PluginsSettingsWidget::updateSettings(bool restore)
 {
+#ifndef USE_GLES
     mShaderPath->setText(AppSupport::getAppShaderEffectsPath(restore));
     mShadersDisabled = AppSupport::getSettings("settings",
                                                "DisabledShaders").toStringList();
     if (restore) {
         mShadersDisabled.clear();
         populateShaderTree();
     }
+#else
+    Q_UNUSED(restore)
+#endif
 }
 
 void PluginsSettingsWidget::populateShaderTree()
 {
+#ifndef USE_GLES
     mShaderTree->setSortingEnabled(false);
     mShaderTree->clear();
     for (auto &shader: mShadersList) {
@@ -138,4 +150,5 @@ void PluginsSettingsWidget::populateShaderTree()
     }
     mShaderTree->setSortingEnabled(true);
     mShaderTree->sortByColumn(0, Qt::AscendingOrder);
+#endif
 }
diff --git a/src/app/main.cpp b/src/app/main.cpp
@@ -51,10 +51,23 @@
 void setDefaultFormat()
 {
     QApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
+
+#ifdef USE_GLES
+    QApplication::setAttribute(Qt::AA_UseOpenGLES);
+#else
     QApplication::setAttribute(Qt::AA_UseDesktopOpenGL);
+#endif
+
     QSurfaceFormat format;
+
+#ifdef USE_GLES
+    format.setVersion(3, 0);
+    format.setProfile(QSurfaceFormat::NoProfile);
+#else
     format.setVersion(3, 3);
     format.setProfile(QSurfaceFormat::CoreProfile);
+#endif
+
     format.setDepthBufferSize(24);
     format.setStencilBufferSize(8);
     format.setSamples(0);
@@ -316,6 +329,7 @@ int main(int argc, char *argv[])
     }
 
     // init shaders
+#ifndef USE_GLES
     try {
         effectsLoader.iniShaderEffects();
     } catch(const std::exception& e) {
@@ -329,6 +343,7 @@ int main(int argc, char *argv[])
         }
         document.actionFinished();
     });
+#endif
 
     // disabled for now
     //effectsLoader.iniCustomBoxes();
diff --git a/src/cmake/friction-common.cmake b/src/cmake/friction-common.cmake
@@ -30,6 +30,7 @@ option(MAC_DEPLOY "Mac Deploy" OFF)
 option(WIN_DEPLOY "Windows Deploy" OFF)
 option(BUILD_SKIA "Build skia" ON)
 option(SKIA_STATIC "Static skia" OFF)
+option(USE_GLES "Use OpenGL ES 3.0 (experimental)" OFF)
 
 set(SKIA_LIB_PATH "/mnt/skia" CACHE STRING "Path to prebuilt skia library")
 
@@ -42,6 +43,9 @@ endif()
 if(${MAC_DEPLOY})
     add_definitions(-DMAC_DEPLOY)
 endif()
+if(USE_GLES)
+    add_compile_definitions(USE_GLES)
+endif()
 
 if(NOT APPLE)
     if(UNIX AND NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
diff --git a/src/core/Private/Tasks/offscreenqgl33c.h b/src/core/Private/Tasks/offscreenqgl33c.h
@@ -46,13 +46,24 @@ class CORE_EXPORT OffscreenQGL33c : public QGL33 {
     }
 
     void makeCurrent() {
-        if(!mContext->makeCurrent(mOffscreenSurface))
+        if (!mContext->makeCurrent(mOffscreenSurface)) {
+#ifdef USE_GLES
+            PrettyRuntimeThrow("Making OpenGL ES context current failed.\n"
+                               "Make sure your GPU drivers support OpenGL ES 3.0.");
+#else
             PrettyRuntimeThrow("Making OpenGL context current failed.\n"
                                "Make sure your GPU drivers support OpenGL 3.3 core.");
-        if(!mInitialized) {
-            if(!initializeOpenGLFunctions())
+#endif
+        }
+        if (!mInitialized) {
+#ifdef USE_GLES
+            initializeOpenGLFunctions();
+#else
+            if (!initializeOpenGLFunctions()) {
                 PrettyRuntimeThrow("Initializing OpenGL 3.3 core functions failed.\n"
                                    "Make sure your GPU drivers support OpenGL 3.3 core.");
+            }
+#endif
             mInitialized = true;
         }
     }
diff --git a/src/core/etexture.cpp b/src/core/etexture.cpp
@@ -59,10 +59,31 @@ SkBitmap eTexture::bitmapSnapshot(QGL33 * const gl) const {
     SkBitmap bitmap;
     const auto info = SkiaHelpers::getPremulRGBAInfo(fWidth, fHeight);
     bitmap.allocPixels(info);
+
+#ifdef USE_GLES
+    GLint currentTexture = 0;
+    gl->glGetIntegerv(GL_TEXTURE_BINDING_2D, &currentTexture);
+
+    GLint oldFbo = 0;
+    gl->glGetIntegerv(GL_FRAMEBUFFER_BINDING, &oldFbo);
+
+    GLuint tempFbo = 0;
+    gl->glGenFramebuffers(1, &tempFbo);
+    gl->glBindFramebuffer(GL_FRAMEBUFFER, tempFbo);
+
+    gl->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                               GL_TEXTURE_2D, currentTexture, 0);
+
+    gl->glReadPixels(0, 0, fWidth, fHeight, GL_RGBA,
+                     GL_UNSIGNED_BYTE, bitmap.getPixels());
+
+    gl->glBindFramebuffer(GL_FRAMEBUFFER, oldFbo);
+    gl->glDeleteFramebuffers(1, &tempFbo);
+#else
     gl->glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA,
                       GL_UNSIGNED_BYTE, bitmap.getPixels());
-//    glReadPixels(0, 0, fWidth, fHeight,
-//                 GL_RGBA, GL_UNSIGNED_BYTE, btmp.getPixels());
+#endif
+
     return bitmap;
 }
 
diff --git a/src/core/glhelpers.cpp b/src/core/glhelpers.cpp
@@ -154,8 +154,23 @@ void gIniProgram(QGL33 * const gl, GLuint& program,
     } catch(...) {
         RuntimeThrow("Could not load shader data from file.");
     }
-    const char* const vShaderCode = vertexCode.c_str();
-    const char* const fShaderCode = fragmentCode.c_str();
+
+#ifdef USE_GLES
+    auto patchShaderGLES = [](std::string& code) {
+        size_t pos = code.find("#version");
+        if (pos != std::string::npos) {
+            size_t endLine = code.find("\n", pos);
+            if (endLine != std::string::npos) {
+                code.replace(pos, endLine - pos, "#version 300 es\nprecision highp float;");
+            }
+        }
+    };
+    patchShaderGLES(vertexCode);
+    patchShaderGLES(fragmentCode);
+#endif
+
+    const char* vShaderCode = vertexCode.c_str();
+    const char* fShaderCode = fragmentCode.c_str();
 
     const GLuint vertexShader = gl->glCreateShader(GL_VERTEX_SHADER);
     gl->glShaderSource(vertexShader, 1, &vShaderCode, nullptr);
diff --git a/src/core/glhelpers.h b/src/core/glhelpers.h
@@ -26,13 +26,19 @@
 #ifndef GLHELPERS_H
 #define GLHELPERS_H
 
-#include <QOpenGLFunctions_3_3_Core>
 #include <QPoint>
 #include "skia/skiaincludes.h"
 
 #include "exceptions.h"
 
+#if USE_GLES
+#include <QOpenGLExtraFunctions>
+typedef QOpenGLExtraFunctions QGL33;
+#else
+#include <QOpenGLFunctions_3_3_Core>
 typedef QOpenGLFunctions_3_3_Core QGL33;
+#endif
+
 #define BUFFER_OFFSET(i) ((void*)(i))
 
 CORE_EXPORT
diff --git a/src/ui/widgets/glwidget.cpp b/src/ui/widgets/glwidget.cpp
@@ -38,9 +38,13 @@ GLWidget::GLWidget(QWidget *parent) : QOpenGLWidget(parent)
 
 void GLWidget::initializeGL()
 {
+#ifdef USE_GLES
+    initializeOpenGLFunctions();
+#else
     if (!initializeOpenGLFunctions()) {
         RuntimeThrow(tr("Initializing OpenGL 3.3 failed."));
     }
+#endif
 
     glClearColor(0, 0, 0, 1);
 
diff --git a/src/ui/widgets/glwindow.cpp b/src/ui/widgets/glwindow.cpp
@@ -84,9 +84,20 @@ void GLWindow::initializeGL() {
             RuntimeThrow("Application-wide shared OpenGL context not found");
         if(context()->shareContext() != globalCtx)
             context()->setShareContext(globalCtx);
-        if(!initializeOpenGLFunctions())
+
+#ifdef USE_GLES
+        if (!context() || !context()->isValid()) {
+            RuntimeThrow("Initializing OpenGL ES failed. Context is invalid. "
+                         "Make sure your GPU supports OpenGL ES 3.0.");
+        }
+        initializeOpenGLFunctions();
+#else
+        if (!initializeOpenGLFunctions()) {
             RuntimeThrow("Initializing OpenGL 3.3 functions failed. "
                          "Make sure your GPU supports OpenGL 3.3.");
+        }
+#endif
+
         initialize();
     } catch(const std::exception& e) {
         gPrintExceptionFatal(e);

Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,10 @@ PluginsSettingsWidget::PluginsSettingsWidget(QWidget *parent)`
`41`	`41`	`, mShaderPath(nullptr)`
`42`	`42`	`, mShaderTree(nullptr)`
`43`	`43`	`{`
	`44`	`+#ifdef USE_GLES`
	`45`	`+ const auto label = new QLabel(tr("Shaders not supported when using OpenGL ES 3.0."), this);`
	`46`	`+ addWidget(label);`
	`47`	`+#else`
`44`	`48`	`mShadersList = EffectsLoader::sInstance->getLoadedShaderEffects();`
`45`	`49`
`46`	`50`	`mShadersDisabled = AppSupport::getSettings("settings",`
`@@ -93,10 +97,12 @@ PluginsSettingsWidget::PluginsSettingsWidget(QWidget *parent)`
`93`	`97`	`.arg(tr("Any changes in this section require a restart of Friction"),`
`94`	`98`	`tr("Also note that shader effects are still considered experimental")));`
`95`	`99`	`addWidget(infoLabel);`
	`100`	`+#endif`
`96`	`101`	`}`
`97`	`102`
`98`	`103`	`void PluginsSettingsWidget::applySettings()`
`99`	`104`	`{`
	`105`	`+#ifndef USE_GLES`
`100`	`106`	`AppSupport::setSettings("settings",`
`101`	`107`	`"CustomShaderPath",`
`102`	`108`	`mShaderPath->text());`
`@@ -109,21 +115,27 @@ void PluginsSettingsWidget::applySettings()`
`109`	`115`	`AppSupport::setSettings("settings",`
`110`	`116`	`"DisabledShaders",`
`111`	`117`	`disabledShaders);`
	`118`	`+#endif`
`112`	`119`	`}`
`113`	`120`
`114`	`121`	`void PluginsSettingsWidget::updateSettings(bool restore)`
`115`	`122`	`{`
	`123`	`+#ifndef USE_GLES`
`116`	`124`	`mShaderPath->setText(AppSupport::getAppShaderEffectsPath(restore));`
`117`	`125`	`mShadersDisabled = AppSupport::getSettings("settings",`
`118`	`126`	`"DisabledShaders").toStringList();`
`119`	`127`	`if (restore) {`
`120`	`128`	`mShadersDisabled.clear();`
`121`	`129`	`populateShaderTree();`
`122`	`130`	`}`
	`131`	`+#else`
	`132`	`+ Q_UNUSED(restore)`
	`133`	`+#endif`
`123`	`134`	`}`
`124`	`135`
`125`	`136`	`void PluginsSettingsWidget::populateShaderTree()`
`126`	`137`	`{`
	`138`	`+#ifndef USE_GLES`
`127`	`139`	`mShaderTree->setSortingEnabled(false);`
`128`	`140`	`mShaderTree->clear();`
`129`	`141`	`for (auto &shader: mShadersList) {`
`@@ -138,4 +150,5 @@ void PluginsSettingsWidget::populateShaderTree()`
`138`	`150`	`}`
`139`	`151`	`mShaderTree->setSortingEnabled(true);`
`140`	`152`	`mShaderTree->sortByColumn(0, Qt::AscendingOrder);`
	`153`	`+#endif`
`141`	`154`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,9 +38,13 @@ GLWidget::GLWidget(QWidget *parent) : QOpenGLWidget(parent)`
`38`	`38`
`39`	`39`	`void GLWidget::initializeGL()`
`40`	`40`	`{`
	`41`	`+#ifdef USE_GLES`
	`42`	`+ initializeOpenGLFunctions();`
	`43`	`+#else`
`41`	`44`	`if (!initializeOpenGLFunctions()) {`
`42`	`45`	`RuntimeThrow(tr("Initializing OpenGL 3.3 failed."));`
`43`	`46`	`}`
	`47`	`+#endif`
`44`	`48`
`45`	`49`	`glClearColor(0, 0, 0, 1);`
`46`	`50`